diff --git a/.ci/bwcVersions b/.ci/bwcVersions
index 782162f3c81ce..a89b89bb8803f 100644
--- a/.ci/bwcVersions
+++ b/.ci/bwcVersions
@@ -17,4 +17,5 @@ BWC_VERSION:
   - "2.6.0"
   - "2.6.1"
   - "2.7.0"
+  - "2.7.1"
   - "2.8.0"
diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml
index 5cf789707c58c..ece87b3eed38a 100644
--- a/.idea/inspectionProfiles/Project_Default.xml
+++ b/.idea/inspectionProfiles/Project_Default.xml
@@ -2,6 +2,9 @@
   <profile version="1.0">
     <option name="myName" value="Project Default" />
     <inspection_tool class="GroovyPointlessBoolean" enabled="false" level="WARNING" enabled_by_default="false" />
+    <inspection_tool class="JavadocDeclaration" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ADDITIONAL_TAGS" value="opensearch.experimental" />
+    </inspection_tool>
     <inspection_tool class="PointlessBooleanExpression" enabled="false" level="WARNING" enabled_by_default="false">
       <option name="m_ignoreExpressionsContainingConstants" value="true" />
     </inspection_tool>
diff --git a/CHANGELOG.md b/CHANGELOG.md
index a2eb99d2fe96f..1fd55ac3b4990 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -30,21 +30,16 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - Bump `wiremock-jre8-standalone` from 2.33.2 to 2.35.0
 - Bump `gson` from 2.10 to 2.10.1
 - Bump `json-schema-validator` from 1.0.73 to 1.0.76
-- Bump `jna` from 5.11.0 to 5.13.0
 - Bump `joni` from 2.1.44 to 2.1.45
-- Bump `commons-io:commons-io` from 2.7 to 2.11.0
 - Bump `org.jruby.joni:joni` from 2.1.45 to 2.1.48
 - Bump `com.google.code.gson:gson` from 2.10 to 2.10.1
 - Bump `com.maxmind.geoip2:geoip2` from 4.0.0 to 4.0.1
 - Bump `com.networknt:json-schema-validator` from 1.0.76 to 1.0.78
-- Bump `com.netflix.nebula:gradle-info-plugin` from 12.0.0 to 12.1.0
 - Bump `com.avast.gradle:gradle-docker-compose-plugin` from 0.16.11 to 0.16.12
 - Bump `org.apache.commons:commons-compress` from 1.22 to 1.23.0
 - Bump `org.apache.commons:commons-configuration2` from 2.8.0 to 2.9.0
 - Bump `com.netflix.nebula:nebula-publishing-plugin` from 19.2.0 to 20.3.0
-- Bump `com.netflix.nebula.ospackage-base` from 11.0.0 to 11.3.0
 - Bump `org.apache.commons:commons-compress` from 1.22 to 1.23.0
-- Bump `com.google.protobuf:protobuf-java` from 3.22.2 to 3.22.3
 - Bump `com.diffplug.spotless` from 6.17.0 to 6.18.0
 - Bump `io.opencensus:opencensus-api` from 0.18.0 to 0.31.1 ([#7291](https://github.com/opensearch-project/OpenSearch/pull/7291))
 
@@ -84,14 +79,26 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ## [Unreleased 2.x]
 ### Added
-- [Extensions] Moving Extensions APIs to protobuf serialization. ([#6960](https://github.com/opensearch-project/OpenSearch/pull/6960))
+- [Extensions] Moving Extensions APIs to support cross versions via protobuf. ([#7402](https://github.com/opensearch-project/OpenSearch/issues/7402))
+- [Extensions] Add IdentityPlugin into core to support Extension identities ([#7246](https://github.com/opensearch-project/OpenSearch/pull/7246))
+- Add connectToNodeAsExtension in TransportService ([#6866](https://github.com/opensearch-project/OpenSearch/pull/6866))
 - Add descending order search optimization through reverse segment read. ([#7244](https://github.com/opensearch-project/OpenSearch/pull/7244))
 
 ### Dependencies
-- Bump `jackson` from 2.14.2 to 2.15.0 ([#7286](https://github.com/opensearch-project/OpenSearch/pull/7286)
+- Bump `com.netflix.nebula:gradle-info-plugin` from 12.0.0 to 12.1.0
+- Bump `com.netflix.nebula:nebula-publishing-plugin` from 19.2.0 to 20.2.0
+- Bump `com.google.protobuf:protobuf-java` from 3.22.2 to 3.22.3
+- Bump `jackson` from 2.14.2 to 2.15.0 ([#7286](https://github.com/opensearch-project/OpenSearch/pull/7286))
+- Bump `com.netflix.nebula:nebula-publishing-plugin` from 20.2.0 to 20.3.0
+- Bump `com.netflix.nebula.ospackage-base` from 11.0.0 to 11.3.0
+- Bump `gradle.plugin.com.github.johnrengelman:shadow` from 7.1.2 to 8.0.0
+- Bump `jna` from 5.11.0 to 5.13.0
+- Bump `commons-io:commons-io` from 2.7 to 2.11.0
+- Bump `org.apache.shiro:shiro-core` from 1.9.1 to 1.11.0 ([#7397](https://github.com/opensearch-project/OpenSearch/pull/7397)
 
 ### Changed
 - Enable `./gradlew build` on MacOS by disabling bcw tests ([#7303](https://github.com/opensearch-project/OpenSearch/pull/7303))
+- Moved concurrent-search from sandbox plugin to server module behind feature flag ([#7203](https://github.com/opensearch-project/OpenSearch/pull/7203))
 
 ### Deprecated
 
@@ -102,4 +109,4 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 ### Security
 
 [Unreleased 3.0]: https://github.com/opensearch-project/OpenSearch/compare/2.x...HEAD
-[Unreleased 2.x]: https://github.com/opensearch-project/OpenSearch/compare/2.5...2.x
\ No newline at end of file
+[Unreleased 2.x]: https://github.com/opensearch-project/OpenSearch/compare/2.7...2.x
diff --git a/DEVELOPER_GUIDE.md b/DEVELOPER_GUIDE.md
index 0dd8fdb479a83..25fca31587cbc 100644
--- a/DEVELOPER_GUIDE.md
+++ b/DEVELOPER_GUIDE.md
@@ -9,6 +9,7 @@
       - [Windows](#windows)
       - [Docker](#docker)
     - [Build](#build)
+      - [Generated Code](#generated-code)
     - [Run Tests](#run-tests)
     - [Run OpenSearch](#run-opensearch)
   - [Use an Editor](#use-an-editor)
@@ -26,6 +27,7 @@
     - [`server`](#server)
     - [`test`](#test)
   - [Java Language Formatting Guidelines](#java-language-formatting-guidelines)
+  - [Adding Dependencies](#adding-dependencies)
     - [Editor / IDE Support](#editor--ide-support)
     - [Formatting Failures](#formatting-failures)
   - [Gradle Build](#gradle-build)
@@ -39,7 +41,7 @@
       - [Distribution Download Plugin](#distribution-download-plugin)
     - [Creating fat-JAR of a Module](#creating-fat-jar-of-a-module)
   - [Components](#components)
-    - [Build libraries & interfaces](#build-libraries--interfaces)
+    - [Build Libraries & Interfaces](#build-libraries--interfaces)
     - [Clients & Libraries](#clients--libraries)
     - [Plugins](#plugins-1)
     - [Indexing & Search](#indexing--search)
@@ -133,6 +135,17 @@ To build a distribution to run on your local platform, run:
 
 All distributions built will be under `distributions/archives`.
 
+#### Generated Code
+
+OpenSearch uses code generators like [Protobuf](https://protobuf.dev/).
+OpenSearch build system already takes a dependency of generating code from protobuf, incase you run into compilation errors, run:
+
+```
+./gradlew generateProto
+```
+
+Generated code in OpenSearch is used to establish cross version compatibility communication for API contracts within OpenSearch.
+
 ### Run Tests
 
 OpenSearch uses a Gradle wrapper for its build. Run `gradlew` on Unix systems, or `gradlew.bat` on Windows in the root of the repository.
@@ -328,6 +341,18 @@ Please follow these formatting guidelines:
 * Note that JavaDoc and block comments i.e. `/* ... */` are not formatted, but line comments i.e `// ...` are.
 * There is an implicit rule that negative boolean expressions should use the form `foo == false` instead of `!foo` for better readability of the code. While this isn't strictly enforced, if might get called out in PR reviews as something to change.
 
+## Adding Dependencies
+
+When adding a new dependency or removing an existing dependency via any `build.gradle` (that are not in the test scope), update the dependency LICENSE and library SHAs.
+
+For example, after adding `api "org.slf4j:slf4j-api:${versions.slf4j}"` to [plugins/discovery-ec2/build.gradle](plugins/discovery-ec2/build.gradle), copy the library `LICENSE.txt` and `NOTICE.txt` to `plugins/discovery-ec2/licenses/slf4j-api-LICENSE.txt` and `plugins/discovery-ec2/licenses/slf4j-api-NOTICE.txt`, then run the following to generate `plugins/discovery-ec2/licenses/slf4j-api-1.7.36.jar.sha1`.
+
+```
+./gradlew :plugins:discovery-ec2:updateSHAs
+```
+
+Ensure that `./gradlew :plugins:discovery-ec2:check` passes before submitting changes.
+
 ### Editor / IDE Support
 
 IntelliJ IDEs can [import](https://blog.jetbrains.com/idea/2014/01/intellij-idea-13-importing-code-formatter-settings-from-eclipse/) the [settings file](buildSrc/formatterConfig.xml), and / or use the [Eclipse Code Formatter](https://plugins.jetbrains.com/plugin/6546-eclipse-code-formatter)
@@ -424,7 +449,7 @@ Refer the installed JAR as any other maven artifact, e.g.
 
 As you work in the OpenSearch repo you may notice issues getting labeled with component labels.  It's a housekeeping task to help group together similar pieces of work.  You can pretty much ignore it, but if you're curious, here's what the different labels mean:
 
-### Build libraries & interfaces
+### Build Libraries & Interfaces
 
 Tasks to make sure the build tasks are useful and packaging and distribution are easy.
 
@@ -437,7 +462,6 @@ Includes:
 - Compatibility
 - Javadoc enforcement
 
-
 ### Clients & Libraries
 
 APIs and communication mechanisms for external connections to OpenSearch.  This includes the “library” directory in OpenSearch (a set of common functions).
@@ -499,6 +523,7 @@ Includes:
 Security is our top priority. Avoid checking in credentials.
 
 #### Installation
+
 Install [awslabs/git-secrets](https://github.com/awslabs/git-secrets) by running the following commands.
 ```
 git clone https://github.com/awslabs/git-secrets.git
@@ -507,6 +532,7 @@ make install
 ```
 
 #### Configuration
+
 You can configure git secrets per repository, you need to change the directory to the root of the repository and run the following command.
 ```
 git secrets --install
@@ -533,11 +559,13 @@ OpenSearch addresses backward and forward compatibility at three different level
 to ensure backwards compatibility are provided below.
 
 #### Data
+
 The data level consists of index and application data file formats. OpenSearch guarantees file formats and indexes are compatible only back to the first release of
 the previous major version. If on disk formats or encodings need to be changed (including index data, cluster state, or any other persisted data) developers must
 use Version checks accordingly (e.g., `Version.onOrAfter`, `Version.before`) to guarantee backwards compatibility.
 
 #### Developer API
+
 The Developer API consists of interfaces and foundation software implementations that enable external users to develop new OpenSearch features. This includes
 obvious components such as the Plugin framework and less obvious components such as REST Action Handlers. When developing a new feature of OpenSearch it is important
 to explicitly mark which implementation components may, or may not, be extended by external implementations. For example, all new API classes with `@opensearch.api`
@@ -547,6 +575,7 @@ guarantee backwards compatibility and may change at any time. The `@deprecated`
 either changed or planned to be removed across minor versions.
 
 #### User API
+
 The User API consists of integration specifications (e.g., [Query Domain Specific Language](https://opensearch.org/docs/latest/opensearch/query-dsl/index/),
 [field mappings](https://opensearch.org/docs/latest/opensearch/mappings/)) and endpoints (e.g., [`_search`](https://opensearch.org/docs/latest/api-reference/search/),
 [`_cat`](https://opensearch.org/docs/latest/api-reference/cat/index/)) users rely on to integrate and use OpenSearch. Backwards compatibility is critical to the
@@ -556,6 +585,7 @@ users of any changes by adding the `>breaking` label on Pull Requests, adding an
 and a log message to the OpenSearch deprecation log files using the `DeprecationLogger`.
 
 #### Experimental Development
+
 Rapidly developing new features often benefit from several release cycles before committing to an official and long term supported (LTS) API. To enable this cycle OpenSearch
 uses an Experimental Development process leveraging [Feature Flags](https://featureflags.io/feature-flags/). This allows a feature to be developed using the same process as
 a LTS feature but with additional guard rails and communication mechanisms to signal to the users and development community the feature is not yet stable, may change in a future
diff --git a/README.md b/README.md
index 9c2eaf07ccbd3..55ff067e4d779 100644
--- a/README.md
+++ b/README.md
@@ -7,7 +7,7 @@
 [![Security Vulnerabilities](https://img.shields.io/github/issues/opensearch-project/OpenSearch/security%20vulnerability?labelColor=red)](https://github.com/opensearch-project/OpenSearch/issues?q=is%3Aissue+is%3Aopen+label%3A"security%20vulnerability")
 [![Open Issues](https://img.shields.io/github/issues/opensearch-project/OpenSearch)](https://github.com/opensearch-project/OpenSearch/issues)
 [![Open Pull Requests](https://img.shields.io/github/issues-pr/opensearch-project/OpenSearch)](https://github.com/opensearch-project/OpenSearch/pulls)
-[![2.6 Open Issues](https://img.shields.io/github/issues/opensearch-project/OpenSearch/v2.6.0)](https://github.com/opensearch-project/OpenSearch/issues?q=is%3Aissue+is%3Aopen+label%3A"v2.6.0")
+[![2.8 Open Issues](https://img.shields.io/github/issues/opensearch-project/OpenSearch/v2.8.0)](https://github.com/opensearch-project/OpenSearch/issues?q=is%3Aissue+is%3Aopen+label%3A"v2.8.0")
 [![3.0 Open Issues](https://img.shields.io/github/issues/opensearch-project/OpenSearch/v3.0.0)](https://github.com/opensearch-project/OpenSearch/issues?q=is%3Aissue+is%3Aopen+label%3A"v3.0.0")
 [![GHA gradle check](https://github.com/opensearch-project/OpenSearch/actions/workflows/gradle-check.yml/badge.svg)](https://github.com/opensearch-project/OpenSearch/actions/workflows/gradle-check.yml)
 [![GHA validate pull request](https://github.com/opensearch-project/OpenSearch/actions/workflows/wrapper.yml/badge.svg)](https://github.com/opensearch-project/OpenSearch/actions/workflows/wrapper.yml)
diff --git a/buildSrc/build.gradle b/buildSrc/build.gradle
index ca763447e709c..9fa3df825b81c 100644
--- a/buildSrc/build.gradle
+++ b/buildSrc/build.gradle
@@ -111,7 +111,7 @@ dependencies {
   api 'org.apache.rat:apache-rat:0.15'
   api 'commons-io:commons-io:2.11.0'
   api "net.java.dev.jna:jna:5.13.0"
-  api 'gradle.plugin.com.github.johnrengelman:shadow:7.1.2'
+  api 'gradle.plugin.com.github.johnrengelman:shadow:8.0.0'
   api 'org.jdom:jdom2:2.0.6.1'
   api "org.jetbrains.kotlin:kotlin-stdlib-jdk8:${props.getProperty('kotlin')}"
   api 'de.thetaphi:forbiddenapis:3.5.1'
diff --git a/buildSrc/src/main/java/org/opensearch/gradle/testclusters/ExtensionsProperties.java b/buildSrc/src/main/java/org/opensearch/gradle/testclusters/ExtensionsProperties.java
new file mode 100644
index 0000000000000..10a79e8325d0b
--- /dev/null
+++ b/buildSrc/src/main/java/org/opensearch/gradle/testclusters/ExtensionsProperties.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.gradle.testclusters;
+
+public class ExtensionsProperties {
+    private String name;
+    private String uniqueId;
+    private String hostAddress;
+    private String port;
+    private String version;
+    private String opensearchVersion;
+    private String minimumCompatibleVersion;
+
+    public ExtensionsProperties(
+        String name,
+        String uniqueId,
+        String hostAddress,
+        String port,
+        String version,
+        String opensearchVersion,
+        String minimumCompatibleVersion
+    ) {
+        this.name = name;
+        this.uniqueId = uniqueId;
+        this.hostAddress = hostAddress;
+        this.port = port;
+        this.version = version;
+        this.opensearchVersion = opensearchVersion;
+        this.minimumCompatibleVersion = minimumCompatibleVersion;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getUniqueId() {
+        return uniqueId;
+    }
+
+    public void setUniqueId(String uniqueId) {
+        this.uniqueId = uniqueId;
+    }
+
+    public String getHostAddress() {
+        return hostAddress;
+    }
+
+    public void setHostAddress(String hostAddress) {
+        this.hostAddress = hostAddress;
+    }
+
+    public String getPort() {
+        return port;
+    }
+
+    public void setPort(String port) {
+        this.port = port;
+    }
+
+    public String getVersion() {
+        return version;
+    }
+
+    public void setVersion(String version) {
+        this.version = version;
+    }
+
+    public String getOpensearchVersion() {
+        return opensearchVersion;
+    }
+
+    public void setOpensearchVersion(String opensearchVersion) {
+        this.opensearchVersion = opensearchVersion;
+    }
+
+    public String getMinimumCompatibleVersion() {
+        return minimumCompatibleVersion;
+    }
+
+    public void setMinimumCompatibleVersion(String minimumCompatibleVersion) {
+        this.minimumCompatibleVersion = minimumCompatibleVersion;
+    }
+}
diff --git a/buildSrc/src/main/java/org/opensearch/gradle/testclusters/OpenSearchCluster.java b/buildSrc/src/main/java/org/opensearch/gradle/testclusters/OpenSearchCluster.java
index 86823b82a379f..b61acc934d590 100644
--- a/buildSrc/src/main/java/org/opensearch/gradle/testclusters/OpenSearchCluster.java
+++ b/buildSrc/src/main/java/org/opensearch/gradle/testclusters/OpenSearchCluster.java
@@ -205,6 +205,11 @@ public void setTestDistribution(TestDistribution distribution) {
         nodes.all(each -> each.setTestDistribution(distribution));
     }
 
+    @Override
+    public void extension(ExtensionsProperties extension) {
+        nodes.all(each -> each.extension(extension));
+    }
+
     @Override
     public void plugin(Provider<RegularFile> plugin) {
         nodes.all(each -> each.plugin(plugin));
diff --git a/buildSrc/src/main/java/org/opensearch/gradle/testclusters/OpenSearchNode.java b/buildSrc/src/main/java/org/opensearch/gradle/testclusters/OpenSearchNode.java
index 35cc49c2e2a9a..7b4b5d354a00b 100644
--- a/buildSrc/src/main/java/org/opensearch/gradle/testclusters/OpenSearchNode.java
+++ b/buildSrc/src/main/java/org/opensearch/gradle/testclusters/OpenSearchNode.java
@@ -46,6 +46,8 @@
 import org.opensearch.gradle.Version;
 import org.opensearch.gradle.VersionProperties;
 import org.opensearch.gradle.info.BuildParams;
+import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.Yaml;
 import org.gradle.api.Action;
 import org.gradle.api.Named;
 import org.gradle.api.NamedDomainObjectContainer;
@@ -92,6 +94,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Scanner;
 import java.util.Set;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
@@ -141,6 +144,7 @@ public class OpenSearchNode implements TestClusterConfiguration {
     private final Map<String, Configuration> pluginAndModuleConfigurations = new HashMap<>();
     private final List<Provider<File>> plugins = new ArrayList<>();
     private final List<Provider<File>> modules = new ArrayList<>();
+    private final List<ExtensionsProperties> extensions = new ArrayList<>();
     final LazyPropertyMap<String, CharSequence> settings = new LazyPropertyMap<>("Settings", this);
     private final LazyPropertyMap<String, CharSequence> keystoreSettings = new LazyPropertyMap<>("Keystore", this);
     private final LazyPropertyMap<String, File> keystoreFiles = new LazyPropertyMap<>("Keystore files", this, FileEntry::new);
@@ -341,6 +345,42 @@ public void module(String moduleProjectPath) {
         module(maybeCreatePluginOrModuleDependency(moduleProjectPath));
     }
 
+    @Override
+    public void extension(ExtensionsProperties extensions) {
+        this.extensions.add(extensions);
+    }
+
+    public void writeExtensionFiles() {
+        try {
+            // Creates extensions.yml in the target directory
+            Path destination = getDistroDir().resolve("extensions").resolve("extensions.yml");
+            if (!Files.exists(getDistroDir().resolve("extensions"))) {
+                Files.createDirectory(getDistroDir().resolve("extensions"));
+            }
+            DumperOptions dumperOptions = new DumperOptions();
+            TestExtensionsList extensionsList = new TestExtensionsList(this.extensions);
+            dumperOptions.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
+            Yaml yaml = new Yaml(dumperOptions);
+            Files.write(destination, yaml.dump(extensionsList).getBytes());
+
+            /*
+             * SnakeYaml creates a Yaml file with an unnecessary line at the top with the class name
+             * This section of code removes that line while keeping everything else the same.
+             */
+
+            Scanner scanner = new Scanner(destination);
+            scanner.nextLine();
+            StringBuilder extensionsString = new StringBuilder();
+            while (scanner.hasNextLine()) {
+                extensionsString.append("\n" + scanner.nextLine());
+            }
+            Files.write(destination, extensionsString.toString().getBytes());
+
+        } catch (IOException e) {
+            throw new UncheckedIOException("Failed to write to extensions.yml", e);
+        }
+    }
+
     @Override
     public void keystore(String key, String value) {
         keystoreSettings.put(key, value);
@@ -511,6 +551,10 @@ public synchronized void start() {
             logToProcessStdout("installed plugins");
         }
 
+        if (!extensions.isEmpty()) {
+            writeExtensionFiles();
+        }
+
         logToProcessStdout("Creating opensearch keystore with password set to [" + keystorePassword + "]");
         if (keystorePassword.length() > 0) {
             runOpenSearchBinScriptWithInput(keystorePassword + "\n" + keystorePassword, "opensearch-keystore", "create", "-p");
@@ -785,6 +829,10 @@ private void startOpenSearchProcess() {
         environment.clear();
         environment.putAll(getOpenSearchEnvironment());
 
+        if (!extensions.isEmpty()) {
+            environment.put("OPENSEARCH_JAVA_OPTS", "-Dopensearch.experimental.feature.extensions.enabled=true");
+        }
+
         // don't buffer all in memory, make sure we don't block on the default pipes
         processBuilder.redirectError(ProcessBuilder.Redirect.appendTo(stderrFile.toFile()));
         processBuilder.redirectOutput(ProcessBuilder.Redirect.appendTo(stdoutFile.toFile()));
diff --git a/buildSrc/src/main/java/org/opensearch/gradle/testclusters/TestClusterConfiguration.java b/buildSrc/src/main/java/org/opensearch/gradle/testclusters/TestClusterConfiguration.java
index b27f205291269..7378804d59d41 100644
--- a/buildSrc/src/main/java/org/opensearch/gradle/testclusters/TestClusterConfiguration.java
+++ b/buildSrc/src/main/java/org/opensearch/gradle/testclusters/TestClusterConfiguration.java
@@ -55,6 +55,8 @@ public interface TestClusterConfiguration {
 
     void setTestDistribution(TestDistribution distribution);
 
+    void extension(ExtensionsProperties extension);
+
     void plugin(Provider<RegularFile> plugin);
 
     void plugin(String pluginProjectPath);
diff --git a/buildSrc/src/main/java/org/opensearch/gradle/testclusters/TestExtensionsList.java b/buildSrc/src/main/java/org/opensearch/gradle/testclusters/TestExtensionsList.java
new file mode 100644
index 0000000000000..ea601e26672a2
--- /dev/null
+++ b/buildSrc/src/main/java/org/opensearch/gradle/testclusters/TestExtensionsList.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.gradle.testclusters;
+
+import java.util.List;
+
+public class TestExtensionsList {
+    private List<ExtensionsProperties> extensions;
+
+    public TestExtensionsList(List<ExtensionsProperties> extensionsList) {
+        extensions = extensionsList;
+    }
+
+    public List<ExtensionsProperties> getExtensions() {
+        return extensions;
+    }
+
+    public void setExtensions(List<ExtensionsProperties> extensionsList) {
+        extensions = extensionsList;
+    }
+}
diff --git a/gradle/missing-javadoc.gradle b/gradle/missing-javadoc.gradle
index ac10d922c9f38..03addc1ba3616 100644
--- a/gradle/missing-javadoc.gradle
+++ b/gradle/missing-javadoc.gradle
@@ -6,6 +6,7 @@
  * compatible open source license.
  */
 
+
 import javax.annotation.Nullable
 import org.gradle.api.tasks.PathSensitive;
 import org.gradle.api.tasks.PathSensitivity;
@@ -135,6 +136,7 @@ configure([
   project(":plugins:discovery-ec2:qa:amazon-ec2"),
   project(":plugins:discovery-gce"),
   project(":plugins:discovery-gce:qa:gce"),
+  project(":plugins:identity-shiro"),
   project(":plugins:ingest-attachment"),
   project(":plugins:mapper-annotated-text"),
   project(":plugins:mapper-murmur3"),
diff --git a/libs/core/src/main/java/org/opensearch/Version.java b/libs/core/src/main/java/org/opensearch/Version.java
index 5550c9e451879..ef3876c3c33dd 100644
--- a/libs/core/src/main/java/org/opensearch/Version.java
+++ b/libs/core/src/main/java/org/opensearch/Version.java
@@ -86,6 +86,7 @@ public class Version implements Comparable<Version>, ToXContentFragment {
     public static final Version V_2_6_0 = new Version(2060099, org.apache.lucene.util.Version.LUCENE_9_5_0);
     public static final Version V_2_6_1 = new Version(2060199, org.apache.lucene.util.Version.LUCENE_9_5_0);
     public static final Version V_2_7_0 = new Version(2070099, org.apache.lucene.util.Version.LUCENE_9_5_0);
+    public static final Version V_2_7_1 = new Version(2070199, org.apache.lucene.util.Version.LUCENE_9_5_0);
     public static final Version V_2_8_0 = new Version(2080099, org.apache.lucene.util.Version.LUCENE_9_5_0);
     public static final Version V_3_0_0 = new Version(3000099, org.apache.lucene.util.Version.LUCENE_9_6_0);
     public static final Version CURRENT = V_3_0_0;
diff --git a/plugins/identity-shiro/build.gradle b/plugins/identity-shiro/build.gradle
new file mode 100644
index 0000000000000..c02f3727f935e
--- /dev/null
+++ b/plugins/identity-shiro/build.gradle
@@ -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.
+ */
+
+apply plugin: 'opensearch.internal-cluster-test'
+
+opensearchplugin {
+  description 'Plugin for identity features in OpenSearch.'
+  classname 'org.opensearch.identity.shiro.ShiroIdentityPlugin'
+  name project.name
+  licenseFile rootProject.file('licenses/APACHE-LICENSE-2.0.txt')
+  noticeFile rootProject.file('NOTICE.txt')
+}
+
+dependencies {
+  implementation 'org.apache.shiro:shiro-core:1.11.0'
+  // Needed for shiro
+  implementation "org.slf4j:slf4j-api:${versions.slf4j}"
+
+  implementation 'commons-beanutils:commons-beanutils:1.9.4'
+  implementation 'commons-logging:commons-logging:1.2'
+  implementation 'commons-lang:commons-lang:2.6'
+
+  implementation "org.bouncycastle:bcprov-jdk15on:${versions.bouncycastle}"
+
+  testImplementation project(path: ':modules:transport-netty4') // for http
+  testImplementation project(path: ':plugins:transport-nio') // for http
+  testImplementation "org.mockito:mockito-core:${versions.mockito}"
+    testImplementation project(path: ':client:rest-high-level')
+}
+
+/*
+ * We have to disable setting the number of available processors as tests in the same JVM randomize processors and will step on each
+ * other if we allow them to set the number of available processors as it's set-once in Netty.
+ */
+test {
+  systemProperty 'opensearch.set.netty.runtime.available.processors', 'false'
+}
+
+internalClusterTest {
+  systemProperty 'opensearch.set.netty.runtime.available.processors', 'false'
+}
+
+thirdPartyAudit.ignoreMissingClasses(
+  'javax.servlet.ServletContextEvent',
+  'javax.servlet.ServletContextListener',
+  'org.apache.avalon.framework.logger.Logger',
+  'org.apache.commons.collections.Closure',
+  'org.apache.commons.collections.FastHashMap',
+  'org.apache.commons.collections.Predicate',
+  'org.apache.commons.collections.Transformer',
+  'org.apache.commons.collections.comparators.ComparableComparator',
+  'org.apache.commons.collections.keyvalue.AbstractMapEntry',
+  'org.apache.commons.configuration2.interpol.ConfigurationInterpolator',
+  'org.apache.log.Hierarchy',
+  'org.apache.log.Logger',
+  'org.apache.log4j.Level',
+  'org.apache.log4j.Logger',
+  'org.apache.log4j.Priority',
+  'org.slf4j.impl.StaticLoggerBinder',
+  'org.slf4j.impl.StaticMDCBinder',
+  'org.slf4j.impl.StaticMarkerBinder'
+)
diff --git a/plugins/identity-shiro/licenses/bcprov-jdk15on-1.70.jar.sha1 b/plugins/identity-shiro/licenses/bcprov-jdk15on-1.70.jar.sha1
new file mode 100644
index 0000000000000..f5e89c0f5ed45
--- /dev/null
+++ b/plugins/identity-shiro/licenses/bcprov-jdk15on-1.70.jar.sha1
@@ -0,0 +1 @@
+4636a0d01f74acaf28082fb62b317f1080118371
\ No newline at end of file
diff --git a/plugins/identity-shiro/licenses/bcprov-jdk15on-LICENSE.txt b/plugins/identity-shiro/licenses/bcprov-jdk15on-LICENSE.txt
new file mode 100644
index 0000000000000..9f27bafe96885
--- /dev/null
+++ b/plugins/identity-shiro/licenses/bcprov-jdk15on-LICENSE.txt
@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2000 - 2013 The Legion of the Bouncy Castle Inc.
+                          (http://www.bouncycastle.org)
+
+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/plugins/identity-shiro/licenses/bcprov-jdk15on-NOTICE.txt b/plugins/identity-shiro/licenses/bcprov-jdk15on-NOTICE.txt
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/plugins/identity-shiro/licenses/commons-beanutils-1.9.4.jar.sha1 b/plugins/identity-shiro/licenses/commons-beanutils-1.9.4.jar.sha1
new file mode 100644
index 0000000000000..b91aa1e1d1f4f
--- /dev/null
+++ b/plugins/identity-shiro/licenses/commons-beanutils-1.9.4.jar.sha1
@@ -0,0 +1 @@
+d52b9abcd97f38c81342bb7e7ae1eee9b73cba51
\ No newline at end of file
diff --git a/plugins/identity-shiro/licenses/commons-beanutils-LICENSE.txt b/plugins/identity-shiro/licenses/commons-beanutils-LICENSE.txt
new file mode 100644
index 0000000000000..d645695673349
--- /dev/null
+++ b/plugins/identity-shiro/licenses/commons-beanutils-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 [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
+
+       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/plugins/identity-shiro/licenses/commons-beanutils-NOTICE.txt b/plugins/identity-shiro/licenses/commons-beanutils-NOTICE.txt
new file mode 100644
index 0000000000000..e1529d40c6bb6
--- /dev/null
+++ b/plugins/identity-shiro/licenses/commons-beanutils-NOTICE.txt
@@ -0,0 +1,5 @@
+Apache Commons BeanUtils
+Copyright 2000-2019 The Apache Software Foundation
+
+This product includes software developed at
+The Apache Software Foundation (http://www.apache.org/).
diff --git a/plugins/identity-shiro/licenses/commons-lang-2.6.jar.sha1 b/plugins/identity-shiro/licenses/commons-lang-2.6.jar.sha1
new file mode 100644
index 0000000000000..4ee9249d2b76f
--- /dev/null
+++ b/plugins/identity-shiro/licenses/commons-lang-2.6.jar.sha1
@@ -0,0 +1 @@
+0ce1edb914c94ebc388f086c6827e8bdeec71ac2
\ No newline at end of file
diff --git a/plugins/identity-shiro/licenses/commons-lang-LICENSE.txt b/plugins/identity-shiro/licenses/commons-lang-LICENSE.txt
new file mode 100644
index 0000000000000..d645695673349
--- /dev/null
+++ b/plugins/identity-shiro/licenses/commons-lang-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 [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
+
+       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/plugins/identity-shiro/licenses/commons-lang-NOTICE.txt b/plugins/identity-shiro/licenses/commons-lang-NOTICE.txt
new file mode 100644
index 0000000000000..780ac0edb3c94
--- /dev/null
+++ b/plugins/identity-shiro/licenses/commons-lang-NOTICE.txt
@@ -0,0 +1,5 @@
+Apache Commons Lang
+Copyright 2001-2022 The Apache Software Foundation
+
+This product includes software developed at
+The Apache Software Foundation (https://www.apache.org/).
diff --git a/plugins/identity-shiro/licenses/commons-logging-1.2.jar.sha1 b/plugins/identity-shiro/licenses/commons-logging-1.2.jar.sha1
new file mode 100644
index 0000000000000..f40f0242448e8
--- /dev/null
+++ b/plugins/identity-shiro/licenses/commons-logging-1.2.jar.sha1
@@ -0,0 +1 @@
+4bfc12adfe4842bf07b657f0369c4cb522955686
\ No newline at end of file
diff --git a/plugins/identity-shiro/licenses/commons-logging-LICENSE.txt b/plugins/identity-shiro/licenses/commons-logging-LICENSE.txt
new file mode 100644
index 0000000000000..d645695673349
--- /dev/null
+++ b/plugins/identity-shiro/licenses/commons-logging-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 [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
+
+       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/plugins/identity-shiro/licenses/commons-logging-NOTICE.txt b/plugins/identity-shiro/licenses/commons-logging-NOTICE.txt
new file mode 100644
index 0000000000000..1a45218353e87
--- /dev/null
+++ b/plugins/identity-shiro/licenses/commons-logging-NOTICE.txt
@@ -0,0 +1,5 @@
+Apache Commons Logging
+Copyright 2003-2016 The Apache Software Foundation
+
+This product includes software developed at
+The Apache Software Foundation (http://www.apache.org/).
diff --git a/plugins/identity-shiro/licenses/shiro-core-1.11.0.jar.sha1 b/plugins/identity-shiro/licenses/shiro-core-1.11.0.jar.sha1
new file mode 100644
index 0000000000000..67c33e15ec689
--- /dev/null
+++ b/plugins/identity-shiro/licenses/shiro-core-1.11.0.jar.sha1
@@ -0,0 +1 @@
+033a70c87e91968a299f1ee00f4e95050312346d
\ No newline at end of file
diff --git a/plugins/identity-shiro/licenses/shiro-core-LICENSE.txt b/plugins/identity-shiro/licenses/shiro-core-LICENSE.txt
new file mode 100644
index 0000000000000..261eeb9e9f8b2
--- /dev/null
+++ b/plugins/identity-shiro/licenses/shiro-core-LICENSE.txt
@@ -0,0 +1,201 @@
+                                 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 [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
+
+       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/plugins/identity-shiro/licenses/shiro-core-NOTICE.txt b/plugins/identity-shiro/licenses/shiro-core-NOTICE.txt
new file mode 100644
index 0000000000000..1a356397fa88c
--- /dev/null
+++ b/plugins/identity-shiro/licenses/shiro-core-NOTICE.txt
@@ -0,0 +1,15 @@
+Apache Shiro
+Copyright 2008-2022 The Apache Software Foundation
+
+This product includes software developed at
+The Apache Software Foundation (http://www.apache.org/).
+
+The implementation for org.apache.shiro.util.SoftHashMap is based
+on initial ideas from Dr. Heinz Kabutz's publicly posted version
+available at http://www.javaspecialists.eu/archive/Issue015.html,
+with continued modifications.
+
+Certain parts (StringUtils, IpAddressMatcher, AntPathMatcherTests, etc.) of the
+source code for this product was copied for simplicity and to reduce
+dependencies from the source code developed by the Spring Framework Project
+(http://www.springframework.org).
diff --git a/plugins/identity-shiro/licenses/slf4j-api-1.7.36.jar.sha1 b/plugins/identity-shiro/licenses/slf4j-api-1.7.36.jar.sha1
new file mode 100644
index 0000000000000..77b9917528382
--- /dev/null
+++ b/plugins/identity-shiro/licenses/slf4j-api-1.7.36.jar.sha1
@@ -0,0 +1 @@
+6c62681a2f655b49963a5983b8b0950a6120ae14
\ No newline at end of file
diff --git a/plugins/identity-shiro/licenses/slf4j-api-LICENSE.txt b/plugins/identity-shiro/licenses/slf4j-api-LICENSE.txt
new file mode 100644
index 0000000000000..8fda22f4d72f6
--- /dev/null
+++ b/plugins/identity-shiro/licenses/slf4j-api-LICENSE.txt
@@ -0,0 +1,21 @@
+Copyright (c) 2004-2014 QOS.ch
+All rights reserved.
+
+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/plugins/identity-shiro/licenses/slf4j-api-NOTICE.txt b/plugins/identity-shiro/licenses/slf4j-api-NOTICE.txt
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/AuthTokenHandler.java b/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/AuthTokenHandler.java
new file mode 100644
index 0000000000000..14801b665f14f
--- /dev/null
+++ b/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/AuthTokenHandler.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.identity.shiro;
+
+import java.util.Optional;
+
+import org.apache.shiro.authc.AuthenticationToken;
+import org.apache.shiro.authc.UsernamePasswordToken;
+import org.opensearch.identity.tokens.BasicAuthToken;
+
+/**
+ * Extracts Shiro's {@link AuthenticationToken} from different types of auth headers
+ *
+ * @opensearch.experimental
+ */
+class AuthTokenHandler {
+
+    /**
+     * Translates into shiro auth token from the given header token
+     * @param authenticationToken the token from which to translate
+     * @return An optional of the shiro auth token for login
+     */
+    public Optional<AuthenticationToken> translateAuthToken(org.opensearch.identity.tokens.AuthToken authenticationToken) {
+        if (authenticationToken instanceof BasicAuthToken) {
+            final BasicAuthToken basicAuthToken = (BasicAuthToken) authenticationToken;
+            return Optional.of(new UsernamePasswordToken(basicAuthToken.getUser(), basicAuthToken.getPassword()));
+        }
+
+        return Optional.empty();
+    }
+}
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
new file mode 100644
index 0000000000000..eee5dd8ce0bd4
--- /dev/null
+++ b/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/ShiroIdentityPlugin.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.identity.shiro;
+
+import org.opensearch.identity.Subject;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.plugins.IdentityPlugin;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.plugins.Plugin;
+import org.apache.shiro.SecurityUtils;
+import org.apache.shiro.mgt.SecurityManager;
+
+/**
+ * Identity implementation with Shiro
+ *
+ * @opensearch.experimental
+ */
+public final class ShiroIdentityPlugin extends Plugin implements IdentityPlugin {
+    private Logger log = LogManager.getLogger(this.getClass());
+
+    private final Settings settings;
+    private final AuthTokenHandler authTokenHandler;
+
+    /**
+     * Create a new instance of the Shiro Identity Plugin
+     *
+     * @param settings settings being used in the configuration
+     */
+    public ShiroIdentityPlugin(final Settings settings) {
+        this.settings = settings;
+        authTokenHandler = new AuthTokenHandler();
+
+        SecurityManager securityManager = new ShiroSecurityManager();
+        SecurityUtils.setSecurityManager(securityManager);
+    }
+
+    /**
+     * Return a Shiro Subject based on the provided authTokenHandler and current subject
+     *
+     * @return The current subject
+     */
+    @Override
+    public Subject getSubject() {
+        return new ShiroSubject(authTokenHandler, SecurityUtils.getSubject());
+    }
+}
diff --git a/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/ShiroSecurityManager.java b/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/ShiroSecurityManager.java
new file mode 100644
index 0000000000000..96cf05ac53a1a
--- /dev/null
+++ b/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/ShiroSecurityManager.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.identity.shiro;
+
+import org.apache.shiro.mgt.DefaultSecurityManager;
+import org.apache.shiro.mgt.DefaultSessionStorageEvaluator;
+import org.apache.shiro.mgt.DefaultSubjectDAO;
+import org.opensearch.identity.shiro.realm.OpenSearchRealm;
+
+/**
+ * OpenSearch specific security manager implementation
+ *
+ * @opensearch.experimental
+ */
+public class ShiroSecurityManager extends DefaultSecurityManager {
+
+    /**
+     * Creates the security manager using a default realm and no session storage
+     */
+    public ShiroSecurityManager() {
+        super(OpenSearchRealm.INSTANCE);
+
+        // By default shiro stores session information into a cache, there were performance
+        // issues with this sessions cache and so are defaulting to a stateless configuration
+        final DefaultSessionStorageEvaluator evaluator = new DefaultSessionStorageEvaluator();
+        evaluator.setSessionStorageEnabled(false);
+
+        final DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
+        subjectDAO.setSessionStorageEvaluator(evaluator);
+        setSubjectDAO(subjectDAO);
+    }
+}
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
new file mode 100644
index 0000000000000..3208d2bb5d8ca
--- /dev/null
+++ b/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/ShiroSubject.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.identity.shiro;
+
+import java.security.Principal;
+import java.util.Objects;
+
+import org.opensearch.identity.Subject;
+import org.opensearch.identity.tokens.AuthToken;
+
+/**
+ * Subject backed by Shiro
+ *
+ * @opensearch.experimental
+ */
+public class ShiroSubject implements Subject {
+    private final AuthTokenHandler authTokenHandler;
+    private final org.apache.shiro.subject.Subject shiroSubject;
+
+    /**
+     * Creates a new shiro subject for use with the IdentityPlugin
+     * Cannot return null
+     * @param authTokenHandler Used to extract auth header info
+     * @param subject The specific subject being authc/z'd
+     */
+    public ShiroSubject(final AuthTokenHandler authTokenHandler, final org.apache.shiro.subject.Subject subject) {
+        this.authTokenHandler = Objects.requireNonNull(authTokenHandler);
+        this.shiroSubject = Objects.requireNonNull(subject);
+    }
+
+    /**
+     * Return the current principal
+     *
+     * @return The current principal
+     */
+    @Override
+    public Principal getPrincipal() {
+        final Object o = shiroSubject.getPrincipal();
+        if (o == null) return null;
+        if (o instanceof Principal) return (Principal) o;
+        return () -> o.toString();
+    }
+
+    /**
+     * Check if another object is equal to this object
+     *
+     * @param obj The object to be compared against this
+     * @return Whether the two objects are equal
+     */
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (obj == null || getClass() != obj.getClass()) return false;
+        final Subject that = (Subject) obj;
+        return Objects.equals(getPrincipal(), that.getPrincipal());
+    }
+
+    /**
+     * Return this Subject's principal as a hash
+     * @return An int hash code
+     */
+    @Override
+    public int hashCode() {
+        return Objects.hash(getPrincipal());
+    }
+
+    /**
+     * Convert this ShiroSubject's principal to a string
+     * @return A string of the subject's principal
+     */
+    @Override
+    public String toString() {
+        return "ShiroSubject(principal=" + getPrincipal() + ")";
+    }
+
+    /**
+     * Logs the user in via authenticating the user against current Shiro realm
+     * @param authenticationToken The authToken to be used for login
+     */
+    public void authenticate(AuthToken authenticationToken) {
+        final org.apache.shiro.authc.AuthenticationToken authToken = authTokenHandler.translateAuthToken(authenticationToken)
+            .orElseThrow(() -> new UnsupportedAuthenticationToken());
+        shiroSubject.login(authToken);
+    }
+}
diff --git a/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/UnsupportedAuthenticationToken.java b/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/UnsupportedAuthenticationToken.java
new file mode 100644
index 0000000000000..f216bbfefe940
--- /dev/null
+++ b/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/UnsupportedAuthenticationToken.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 org.opensearch.identity.shiro;
+
+/** Thrown if the authentication token was invalid */
+public class UnsupportedAuthenticationToken extends RuntimeException {}
diff --git a/sandbox/plugins/concurrent-search/src/main/java/org/opensearch/search/query/package-info.java b/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/package-info.java
similarity index 61%
rename from sandbox/plugins/concurrent-search/src/main/java/org/opensearch/search/query/package-info.java
rename to plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/package-info.java
index 0f98ae7682a84..49e276f11f660 100644
--- a/sandbox/plugins/concurrent-search/src/main/java/org/opensearch/search/query/package-info.java
+++ b/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/package-info.java
@@ -7,6 +7,6 @@
  */
 
 /**
- * {@link org.opensearch.search.query.QueryPhaseSearcher} implementation for concurrent search
+ * Identity implementation using Shiro
  */
-package org.opensearch.search.query;
+package org.opensearch.identity.shiro;
diff --git a/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/realm/BCryptPasswordMatcher.java b/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/realm/BCryptPasswordMatcher.java
new file mode 100644
index 0000000000000..a2cb78425929e
--- /dev/null
+++ b/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/realm/BCryptPasswordMatcher.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.identity.shiro.realm;
+
+import org.apache.shiro.authc.AuthenticationInfo;
+import org.apache.shiro.authc.AuthenticationToken;
+import org.apache.shiro.authc.UsernamePasswordToken;
+import org.apache.shiro.authc.credential.CredentialsMatcher;
+import org.bouncycastle.crypto.generators.OpenBSDBCrypt;
+
+/**
+ * Password matcher for BCrypt
+ *
+ * @opensearch.experimental
+ */
+public class BCryptPasswordMatcher implements CredentialsMatcher {
+
+    /**
+     * Check if the provided authentication token and authentication info match one another
+     * @param token   the {@code AuthenticationToken} submitted during the authentication attempt
+     * @param info the {@code AuthenticationInfo} stored in the system.
+     * @return A boolean showing whether the token credentials match the info or not.
+     */
+    @Override
+    public boolean doCredentialsMatch(AuthenticationToken token, AuthenticationInfo info) {
+        final UsernamePasswordToken userToken = (UsernamePasswordToken) token;
+        return OpenBSDBCrypt.checkPassword((String) info.getCredentials(), userToken.getPassword());
+    }
+
+}
diff --git a/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/realm/OpenSearchRealm.java b/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/realm/OpenSearchRealm.java
new file mode 100644
index 0000000000000..e005d7c3360cf
--- /dev/null
+++ b/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/realm/OpenSearchRealm.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.identity.shiro.realm;
+
+import org.apache.shiro.authc.AuthenticationException;
+import org.apache.shiro.authc.AuthenticationInfo;
+import org.apache.shiro.authc.AuthenticationToken;
+import org.apache.shiro.authc.IncorrectCredentialsException;
+import org.apache.shiro.authc.SimpleAuthenticationInfo;
+import org.apache.shiro.authc.UnknownAccountException;
+import org.apache.shiro.authc.UsernamePasswordToken;
+import org.apache.shiro.authc.pam.UnsupportedTokenException;
+import org.apache.shiro.realm.AuthenticatingRealm;
+import org.apache.shiro.authc.UsernamePasswordToken;
+
+import org.opensearch.identity.NamedPrincipal;
+
+import java.util.Objects;
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * Internal Realm is a custom realm using the internal OpenSearch IdP
+ *
+ * @opensearch.experimental
+ */
+public class OpenSearchRealm extends AuthenticatingRealm {
+    private static final String DEFAULT_REALM_NAME = "internal";
+
+    /**
+     * The instance of the realm to be constructed through the builder method
+     */
+    public static final OpenSearchRealm INSTANCE = new OpenSearchRealm.Builder(DEFAULT_REALM_NAME).build();
+
+    private final String realmName;
+
+    private Map<String, User> internalUsers;
+
+    /**
+     * Instantiate a new OpenSearchRealm
+     *
+     * @param realmName The name of the realm
+     * @param internalUsers A map of internal users
+     */
+    private OpenSearchRealm(final String realmName, final Map<String, User> internalUsers) {
+        super(new BCryptPasswordMatcher());
+        this.realmName = realmName;
+        this.internalUsers = internalUsers;
+        setAuthenticationTokenClass(UsernamePasswordToken.class);
+    }
+
+    /**
+     * An internal class representing a realm builder
+     *
+     */
+    public static final class Builder {
+        private final String name;
+
+        /**
+         *  Instantiate a realm builder
+         * @param name The name of the realm builder
+         */
+        public Builder(final String name) {
+            this.name = Objects.requireNonNull(name);
+        }
+
+        /**
+         * Create a new OpenSearchRealm
+         *
+         * @return A new realm
+         */
+        public OpenSearchRealm build() {
+            // TODO: Replace hardcoded admin user / user map with an external provider
+            final User adminUser = new User();
+            adminUser.setUsername(new NamedPrincipal("admin"));
+            adminUser.setBcryptHash("$2a$12$VcCDgh2NDk07JGN0rjGbM.Ad41qVR/YFJcgHp0UGns5JDymv..TOG"); // Password 'admin'
+            final Map<String, User> internalUsers = Map.of("admin", adminUser);
+            return new OpenSearchRealm(name, internalUsers);
+        }
+    }
+
+    /**
+     * Return an internal user given a principalIdentifier
+     *
+     * @param principalIdentifier The string of the identifier
+     * @return The associated user
+     * @throws UnknownAccountException when the principal identifier has no user match
+     */
+    public User getInternalUser(final String principalIdentifier) throws UnknownAccountException {
+        final User userRecord = internalUsers.get(principalIdentifier);
+        if (userRecord == null) {
+            throw new UnknownAccountException();
+        }
+        return userRecord;
+    }
+
+    /**
+     * Gets the authentication info associated with a specific authentication token
+     *
+     * @param token the authentication token containing the user's principal and credentials.
+     * @return Authentication info associated with the auth token
+     * @throws AuthenticationException When the auth token has no valid info
+     */
+    @Override
+    protected AuthenticationInfo doGetAuthenticationInfo(final AuthenticationToken token) throws AuthenticationException {
+        if (token instanceof UsernamePasswordToken) {
+            final String username = ((UsernamePasswordToken) token).getUsername();
+            // Look up the user by the provide username
+            final User userRecord = getInternalUser(username);
+            // TODO: Check for other things, like a locked account, expired password, etc.
+
+            // Verify the user
+            final SimpleAuthenticationInfo sai = new SimpleAuthenticationInfo(
+                userRecord.getUsername(),
+                userRecord.getBcryptHash(),
+                realmName
+            );
+
+            final boolean successfulAuthentication = getCredentialsMatcher().doCredentialsMatch(token, sai);
+
+            if (successfulAuthentication) {
+                // TODO: Check for anything else that might prevent login (expired password, locked account, etc.)
+                // if (other problems) {
+                // throw new CredentialsException(); // Or something more specific
+                // }
+                // Success!
+                return sai;
+            } else {
+                // Bad password
+                throw new IncorrectCredentialsException();
+            }
+        }
+
+        // If the token was not handled, it was unsupported
+        final String tokenClassName = Optional.ofNullable(token).map(Object::getClass).map(Class::getName).orElse("null");
+        throw new UnsupportedTokenException("Unable to support authentication token " + tokenClassName);
+    }
+}
diff --git a/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/realm/User.java b/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/realm/User.java
new file mode 100644
index 0000000000000..35b3348a955d7
--- /dev/null
+++ b/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/realm/User.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.identity.shiro.realm;
+
+import org.opensearch.identity.NamedPrincipal;
+
+/**
+ * A non-volatile and immutable object in the storage.
+ *
+ * @opensearch.experimental
+ */
+public class User {
+
+    private NamedPrincipal username;
+    private String bcryptHash;
+
+    /**
+     * Get the User's username as a NamedPrincipal
+     * @return the named principal representing the username
+     */
+    public NamedPrincipal getUsername() {
+        return username;
+    }
+
+    /**
+     * Set the User's username
+     * @param username NamedPrincipal representing the username to be set
+     */
+    public void setUsername(NamedPrincipal username) {
+        this.username = username;
+    }
+
+    /**
+     * Get the User's hash
+     * @return The User's hash as a string
+     */
+    public String getBcryptHash() {
+        return bcryptHash;
+    }
+
+    /**
+     * Set the User's hash
+     * @param bcryptHash A string to be set as the User's hash
+     */
+    public void setBcryptHash(String bcryptHash) {
+        this.bcryptHash = bcryptHash;
+    }
+}
diff --git a/sandbox/plugins/concurrent-search/src/main/java/org/opensearch/search/package-info.java b/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/realm/package-info.java
similarity index 56%
rename from sandbox/plugins/concurrent-search/src/main/java/org/opensearch/search/package-info.java
rename to plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/realm/package-info.java
index 041f914fab7d7..888f54c6e37ea 100644
--- a/sandbox/plugins/concurrent-search/src/main/java/org/opensearch/search/package-info.java
+++ b/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/realm/package-info.java
@@ -6,7 +6,5 @@
  * compatible open source license.
  */
 
-/**
- * The implementation of the experimental plugin which implements the concurrent search over Apache Lucene segments.
- */
-package org.opensearch.search;
+/** Classes for the internal OpenSearch realm */
+package org.opensearch.identity.shiro.realm;
diff --git a/plugins/identity-shiro/src/main/plugin-metadata/plugin-security.policy b/plugins/identity-shiro/src/main/plugin-metadata/plugin-security.policy
new file mode 100644
index 0000000000000..120d1d8fbdb3a
--- /dev/null
+++ b/plugins/identity-shiro/src/main/plugin-metadata/plugin-security.policy
@@ -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.
+ */
+
+grant {
+
+};
diff --git a/plugins/identity-shiro/src/test/java/org/opensearch/identity/shiro/AuthTokenHandlerTests.java b/plugins/identity-shiro/src/test/java/org/opensearch/identity/shiro/AuthTokenHandlerTests.java
new file mode 100644
index 0000000000000..942d777df2086
--- /dev/null
+++ b/plugins/identity-shiro/src/test/java/org/opensearch/identity/shiro/AuthTokenHandlerTests.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.identity.shiro;
+
+import org.apache.shiro.authc.AuthenticationToken;
+import org.apache.shiro.authc.UsernamePasswordToken;
+import org.opensearch.identity.tokens.BasicAuthToken;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.Before;
+
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.notNullValue;
+
+import java.util.Optional;
+
+public class AuthTokenHandlerTests extends OpenSearchTestCase {
+
+    private AuthTokenHandler authTokenHandler;
+
+    @Before
+    public void testSetup() {
+        authTokenHandler = new AuthTokenHandler();
+    }
+
+    public void testShouldExtractBasicAuthTokenSuccessfully() {
+        final BasicAuthToken authToken = new BasicAuthToken("Basic YWRtaW46YWRtaW4="); // admin:admin
+
+        final AuthenticationToken translatedToken = authTokenHandler.translateAuthToken(authToken).get();
+        assertThat(translatedToken, is(instanceOf(UsernamePasswordToken.class)));
+
+        final UsernamePasswordToken usernamePasswordToken = (UsernamePasswordToken) translatedToken;
+        assertThat(usernamePasswordToken, notNullValue());
+        assertThat(usernamePasswordToken.getUsername(), equalTo("admin"));
+        assertThat(new String(usernamePasswordToken.getPassword()), equalTo("admin"));
+    }
+
+    public void testShouldExtractBasicAuthTokenSuccessfully_twoSemiColonPassword() {
+        final BasicAuthToken authToken = new BasicAuthToken("Basic dGVzdDp0ZTpzdA=="); // test:te:st
+
+        final AuthenticationToken translatedToken = authTokenHandler.translateAuthToken(authToken).get();
+        assertThat(translatedToken, is(instanceOf(UsernamePasswordToken.class)));
+
+        final UsernamePasswordToken usernamePasswordToken = (UsernamePasswordToken) translatedToken;
+        assertThat(usernamePasswordToken, notNullValue());
+        assertThat(usernamePasswordToken.getUsername(), equalTo("test"));
+        assertThat(new String(usernamePasswordToken.getPassword()), equalTo("te:st"));
+    }
+
+    public void testShouldReturnNullWhenExtractingNullToken() {
+        final Optional<AuthenticationToken> translatedToken = authTokenHandler.translateAuthToken(null);
+
+        assertThat(translatedToken.isEmpty(), is(true));
+    }
+}
diff --git a/plugins/identity-shiro/src/test/java/org/opensearch/identity/shiro/ShiroSubjectTests.java b/plugins/identity-shiro/src/test/java/org/opensearch/identity/shiro/ShiroSubjectTests.java
new file mode 100644
index 0000000000000..baf6090f79ff3
--- /dev/null
+++ b/plugins/identity-shiro/src/test/java/org/opensearch/identity/shiro/ShiroSubjectTests.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.identity.shiro;
+
+import org.opensearch.test.OpenSearchTestCase;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.verify;
+import org.junit.Before;
+import org.junit.After;
+
+import java.security.Principal;
+
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.hamcrest.Matchers.nullValue;
+import static org.hamcrest.Matchers.equalTo;
+
+public class ShiroSubjectTests extends OpenSearchTestCase {
+
+    private org.apache.shiro.subject.Subject shiroSubject;
+    private AuthTokenHandler authTokenHandler;
+    private ShiroSubject subject;
+
+    @Before
+    public void setup() {
+        shiroSubject = mock(org.apache.shiro.subject.Subject.class);
+        authTokenHandler = mock(AuthTokenHandler.class);
+        subject = new ShiroSubject(authTokenHandler, shiroSubject);
+    }
+
+    @After
+    public void cleanup() {
+        verifyNoMoreInteractions(shiroSubject);
+    }
+
+    public void testGetPrincipal_null() {
+        when(shiroSubject.getPrincipal()).thenReturn(null);
+
+        final Principal result = subject.getPrincipal();
+
+        assertThat(result, nullValue());
+        verify(shiroSubject).getPrincipal();
+    }
+
+    public void testGetPrincipal_principal() {
+        final Principal mockPrincipal = mock(Principal.class);
+        when(shiroSubject.getPrincipal()).thenReturn(mockPrincipal);
+
+        final Principal result = subject.getPrincipal();
+
+        assertThat(result, equalTo(mockPrincipal));
+        verify(shiroSubject).getPrincipal();
+    }
+
+    public void testGetPrincipal_otherType() {
+        final Object objPrincipal = mock(Object.class);
+        when(shiroSubject.getPrincipal()).thenReturn(objPrincipal);
+        when(objPrincipal.toString()).thenReturn("objectPrincipalString");
+
+        final Principal result = subject.getPrincipal();
+
+        // assertThat(result, equalTo("objectPrincipalString"));
+        verify(shiroSubject).getPrincipal();
+        verifyNoMoreInteractions(objPrincipal);
+    }
+
+}
diff --git a/plugins/identity-shiro/src/test/java/org/opensearch/identity/shiro/realm/BCryptPasswordMatcherTests.java b/plugins/identity-shiro/src/test/java/org/opensearch/identity/shiro/realm/BCryptPasswordMatcherTests.java
new file mode 100644
index 0000000000000..37c8c4c220b58
--- /dev/null
+++ b/plugins/identity-shiro/src/test/java/org/opensearch/identity/shiro/realm/BCryptPasswordMatcherTests.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.identity.shiro.realm;
+
+import org.opensearch.test.OpenSearchTestCase;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.hamcrest.Matchers.equalTo;
+
+import org.apache.shiro.authc.UsernamePasswordToken;
+import org.apache.shiro.authc.AuthenticationInfo;
+
+public class BCryptPasswordMatcherTests extends OpenSearchTestCase {
+
+    public void testCredentialMatch() {
+        final UsernamePasswordToken token = mock(UsernamePasswordToken.class);
+        when(token.getPassword()).thenReturn("admin".toCharArray());
+        final AuthenticationInfo info = mock(AuthenticationInfo.class);
+        when(info.getCredentials()).thenReturn("$2a$12$VcCDgh2NDk07JGN0rjGbM.Ad41qVR/YFJcgHp0UGns5JDymv..TOG");
+
+        final BCryptPasswordMatcher matcher = new BCryptPasswordMatcher();
+        final boolean result = matcher.doCredentialsMatch(token, info);
+
+        assertThat(result, equalTo(true));
+    }
+
+    public void testCredentialDoNotMatch() {
+        final UsernamePasswordToken token = mock(UsernamePasswordToken.class);
+        when(token.getPassword()).thenReturn("HashedPassword".toCharArray());
+        final AuthenticationInfo info = mock(AuthenticationInfo.class);
+        when(info.getCredentials()).thenReturn("$2a$12$VcCDgh2NDk07JGN0rQGbM.Ad41qVR/YFJcgHp0UGns5JDymv..TOG");
+
+        final BCryptPasswordMatcher matcher = new BCryptPasswordMatcher();
+        final boolean result = matcher.doCredentialsMatch(token, info);
+
+        assertThat(result, equalTo(false));
+    }
+}
diff --git a/plugins/identity-shiro/src/test/java/org/opensearch/identity/shiro/realm/OpenSearchRealmTests.java b/plugins/identity-shiro/src/test/java/org/opensearch/identity/shiro/realm/OpenSearchRealmTests.java
new file mode 100644
index 0000000000000..d6129c238408a
--- /dev/null
+++ b/plugins/identity-shiro/src/test/java/org/opensearch/identity/shiro/realm/OpenSearchRealmTests.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.identity.shiro.realm;
+
+import org.apache.shiro.authc.AuthenticationInfo;
+import org.apache.shiro.authc.IncorrectCredentialsException;
+import org.apache.shiro.authc.UsernamePasswordToken;
+import org.junit.Before;
+import org.opensearch.test.OpenSearchTestCase;
+
+public class OpenSearchRealmTests extends OpenSearchTestCase {
+
+    private OpenSearchRealm realm;
+
+    @Before
+    public void setup() {
+        realm = new OpenSearchRealm.Builder("test").build();
+    }
+
+    public void testGetAuthenticationInfoUserExists() {
+        final UsernamePasswordToken token = new UsernamePasswordToken("admin", "admin");
+        final User admin = realm.getInternalUser("admin");
+        final AuthenticationInfo adminInfo = realm.getAuthenticationInfo(token);
+        assertNotNull(adminInfo);
+    }
+
+    public void testGetAuthenticationInfoUserExistsWrongPassword() {
+        final UsernamePasswordToken token = new UsernamePasswordToken("admin", "wrong_password");
+        final User admin = realm.getInternalUser("admin");
+
+        assertThrows(IncorrectCredentialsException.class, () -> realm.getAuthenticationInfo(token));
+    }
+}
diff --git a/qa/smoke-test-http/build.gradle b/qa/smoke-test-http/build.gradle
index 2402c9b807283..f48ddc26d929b 100644
--- a/qa/smoke-test-http/build.gradle
+++ b/qa/smoke-test-http/build.gradle
@@ -35,7 +35,8 @@ apply plugin: 'opensearch.test-with-dependencies'
 
 dependencies {
   testImplementation project(path: ':modules:transport-netty4') // for http
-  testImplementation project(path: ':plugins:transport-nio') // for http
+  testImplementation project(path: ':plugins:transport-nio')
+  testImplementation project(path: ':plugins:identity-shiro') // for http
 }
 
 integTest {
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
new file mode 100644
index 0000000000000..45202f6dcbfce
--- /dev/null
+++ b/qa/smoke-test-http/src/test/java/org/opensearch/http/IdentityAuthenticationIT.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.http;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.Collection;
+import org.junit.Assert;
+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.Settings;
+import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.identity.shiro.ShiroIdentityPlugin;
+import org.opensearch.plugins.Plugin;
+import org.opensearch.rest.RestStatus;
+
+import org.opensearch.test.OpenSearchIntegTestCase;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.transport.Netty4ModulePlugin;
+import org.opensearch.transport.nio.NioTransportPlugin;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.core.StringContains.containsString;
+
+@OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.SUITE, supportsDedicatedMasters = false, numDataNodes = 1)
+public class IdentityAuthenticationIT extends HttpSmokeTestCase {
+
+    @Override
+    protected Settings nodeSettings(int nodeOrdinal) {
+        return Settings.builder()
+            .put(super.nodeSettings(nodeOrdinal))
+            .put(FeatureFlags.IDENTITY, "true")
+            .build();
+    }
+
+    @Override
+    protected Collection<Class<? extends Plugin>> nodePlugins() {
+        return Arrays.asList(OpenSearchTestCase.getTestTransportPlugin(), Netty4ModulePlugin.class, NioTransportPlugin.class, ShiroIdentityPlugin.class);
+    }
+
+
+    public void testBasicAuthSuccess() throws Exception {
+        final Response response = createHealthRequest("Basic YWRtaW46YWRtaW4="); // admin:admin
+        final String content = new String(response.getEntity().getContent().readAllBytes(), StandardCharsets.UTF_8);
+
+        Assert.assertThat(content, response.getStatusLine().getStatusCode(), equalTo(RestStatus.OK.getStatus()));
+        Assert.assertThat(content, containsString("green"));
+    }
+
+    public void testBasicAuthUnauthorized_invalidHeader() throws Exception {
+        final Response response = createHealthRequest("Basic aaaa"); // invalid username password
+        final String content = new String(response.getEntity().getContent().readAllBytes(), StandardCharsets.UTF_8);
+
+        Assert.assertThat(content, response.getStatusLine().getStatusCode(), equalTo(RestStatus.UNAUTHORIZED.getStatus()));
+        Assert.assertThat(content, containsString("Illegally formed basic authorization header"));
+    }
+
+    public void testBasicAuthUnauthorized_wrongPassword() throws Exception {
+        final Response response = createHealthRequest("Basic YWRtaW46aW52YWxpZFBhc3N3b3Jk"); // admin:invalidPassword
+        final String content = new String(response.getEntity().getContent().readAllBytes(), StandardCharsets.UTF_8);
+
+        Assert.assertThat(content, response.getStatusLine().getStatusCode(), equalTo(RestStatus.UNAUTHORIZED.getStatus()));
+    }
+
+    public void testBasicAuthUnauthorized_unknownUser() throws Exception {
+        final Response response = createHealthRequest("Basic dXNlcjpkb2VzTm90RXhpc3Q="); // user:doesNotExist
+        final String content = new String(response.getEntity().getContent().readAllBytes(), StandardCharsets.UTF_8);
+
+        Assert.assertThat(content, response.getStatusLine().getStatusCode(), equalTo(RestStatus.UNAUTHORIZED.getStatus()));
+    }
+
+    private Response createHealthRequest(final String authorizationHeaderValue) throws Exception {
+        final Request request = new Request("GET", "/_cluster/health");
+        final RequestOptions options = RequestOptions.DEFAULT.toBuilder().addHeader("Authorization", authorizationHeaderValue).build();
+        request.setOptions(options);
+
+        try {
+            final Response response = OpenSearchIntegTestCase.getRestClient().performRequest(request);
+            return response;
+        } catch (final ResponseException re) {
+            return re.getResponse();
+        }
+    }
+}
diff --git a/sandbox/plugins/concurrent-search/build.gradle b/sandbox/plugins/concurrent-search/build.gradle
deleted file mode 100644
index 0e766dc4fc1ba..0000000000000
--- a/sandbox/plugins/concurrent-search/build.gradle
+++ /dev/null
@@ -1,42 +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.
- *
- * Modifications Copyright OpenSearch Contributors. See
- * GitHub history for details.
- */
-
-/*
- * 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.
- */
-apply plugin: 'opensearch.opensearchplugin'
-apply plugin: 'opensearch.yaml-rest-test'
-
-opensearchplugin {
-  name 'concurrent-search'
-  description 'The experimental plugin which implements concurrent search over Apache Lucene segments'
-  classname 'org.opensearch.search.ConcurrentSegmentSearchPlugin'
-  licenseFile rootProject.file('licenses/APACHE-LICENSE-2.0.txt')
-  noticeFile rootProject.file('NOTICE.txt')
-}
-
-yamlRestTest.enabled = false;
-testingConventions.enabled = false;
diff --git a/sandbox/plugins/concurrent-search/src/main/java/org/opensearch/search/ConcurrentSegmentSearchPlugin.java b/sandbox/plugins/concurrent-search/src/main/java/org/opensearch/search/ConcurrentSegmentSearchPlugin.java
deleted file mode 100644
index da999e40f0f07..0000000000000
--- a/sandbox/plugins/concurrent-search/src/main/java/org/opensearch/search/ConcurrentSegmentSearchPlugin.java
+++ /dev/null
@@ -1,53 +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;
-
-import org.opensearch.common.settings.Settings;
-import org.opensearch.common.util.concurrent.OpenSearchExecutors;
-import org.opensearch.plugins.Plugin;
-import org.opensearch.plugins.SearchPlugin;
-import org.opensearch.search.query.ConcurrentQueryPhaseSearcher;
-import org.opensearch.search.query.QueryPhaseSearcher;
-import org.opensearch.threadpool.ExecutorBuilder;
-import org.opensearch.threadpool.FixedExecutorBuilder;
-import org.opensearch.threadpool.ThreadPool;
-
-import java.util.Collections;
-import java.util.List;
-import java.util.Optional;
-
-/**
- * The experimental plugin which implements the concurrent search over Apache Lucene segments.
- */
-public class ConcurrentSegmentSearchPlugin extends Plugin implements SearchPlugin {
-    private static final String INDEX_SEARCHER = "index_searcher";
-
-    /**
-     * Default constructor
-     */
-    public ConcurrentSegmentSearchPlugin() {}
-
-    @Override
-    public Optional<QueryPhaseSearcher> getQueryPhaseSearcher() {
-        return Optional.of(new ConcurrentQueryPhaseSearcher());
-    }
-
-    @Override
-    public List<ExecutorBuilder<?>> getExecutorBuilders(Settings settings) {
-        final int allocatedProcessors = OpenSearchExecutors.allocatedProcessors(settings);
-        return Collections.singletonList(
-            new FixedExecutorBuilder(settings, INDEX_SEARCHER, allocatedProcessors, 1000, "thread_pool." + INDEX_SEARCHER)
-        );
-    }
-
-    @Override
-    public Optional<ExecutorServiceProvider> getIndexSearcherExecutorProvider() {
-        return Optional.of((ThreadPool threadPool) -> threadPool.executor(INDEX_SEARCHER));
-    }
-}
diff --git a/sandbox/plugins/concurrent-search/src/test/java/org/opensearch/search/profile/query/QueryProfilerTests.java b/sandbox/plugins/concurrent-search/src/test/java/org/opensearch/search/profile/query/QueryProfilerTests.java
deleted file mode 100644
index 0b88abb314fcd..0000000000000
--- a/sandbox/plugins/concurrent-search/src/test/java/org/opensearch/search/profile/query/QueryProfilerTests.java
+++ /dev/null
@@ -1,316 +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.profile.query;
-
-import com.carrotsearch.randomizedtesting.annotations.ParametersFactory;
-
-import org.apache.lucene.document.Document;
-import org.apache.lucene.document.Field.Store;
-import org.apache.lucene.document.StringField;
-import org.apache.lucene.index.DirectoryReader;
-import org.apache.lucene.index.IndexReader;
-import org.apache.lucene.index.IndexWriter;
-import org.apache.lucene.index.LeafReaderContext;
-import org.apache.lucene.index.Term;
-import org.apache.lucene.search.Explanation;
-import org.apache.lucene.search.IndexSearcher;
-import org.apache.lucene.search.LRUQueryCache;
-import org.apache.lucene.search.LeafCollector;
-import org.apache.lucene.search.Query;
-import org.apache.lucene.search.QueryCachingPolicy;
-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.Sort;
-import org.apache.lucene.search.TermQuery;
-import org.apache.lucene.search.TotalHitCountCollector;
-import org.apache.lucene.search.Weight;
-import org.apache.lucene.store.Directory;
-import org.apache.lucene.tests.index.RandomIndexWriter;
-import org.apache.lucene.tests.search.RandomApproximationQuery;
-import org.apache.lucene.tests.util.TestUtil;
-import org.opensearch.common.util.io.IOUtils;
-import org.opensearch.search.internal.ContextIndexSearcher;
-import org.opensearch.search.profile.ProfileResult;
-import org.opensearch.test.OpenSearchTestCase;
-import org.opensearch.threadpool.ThreadPool;
-import org.junit.After;
-import org.junit.Before;
-
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.TimeUnit;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.greaterThan;
-
-public class QueryProfilerTests extends OpenSearchTestCase {
-
-    private Directory dir;
-    private IndexReader reader;
-    private ContextIndexSearcher searcher;
-    private ExecutorService executor;
-
-    @ParametersFactory
-    public static Collection<Object[]> concurrency() {
-        return Arrays.asList(new Integer[] { 0 }, new Integer[] { 5 });
-    }
-
-    public QueryProfilerTests(int concurrency) {
-        this.executor = (concurrency > 0) ? Executors.newFixedThreadPool(concurrency) : null;
-    }
-
-    @Before
-    public void setUp() throws Exception {
-        super.setUp();
-
-        dir = newDirectory();
-        RandomIndexWriter w = new RandomIndexWriter(random(), dir);
-        final int numDocs = TestUtil.nextInt(random(), 1, 20);
-        for (int i = 0; i < numDocs; ++i) {
-            final int numHoles = random().nextInt(5);
-            for (int j = 0; j < numHoles; ++j) {
-                w.addDocument(new Document());
-            }
-            Document doc = new Document();
-            doc.add(new StringField("foo", "bar", Store.NO));
-            w.addDocument(doc);
-        }
-        reader = w.getReader();
-        w.close();
-        searcher = new ContextIndexSearcher(
-            reader,
-            IndexSearcher.getDefaultSimilarity(),
-            IndexSearcher.getDefaultQueryCache(),
-            ALWAYS_CACHE_POLICY,
-            true,
-            executor
-        );
-    }
-
-    @After
-    public void tearDown() throws Exception {
-        super.tearDown();
-
-        LRUQueryCache cache = (LRUQueryCache) searcher.getQueryCache();
-        assertThat(cache.getHitCount(), equalTo(0L));
-        assertThat(cache.getCacheCount(), equalTo(0L));
-        assertThat(cache.getTotalCount(), equalTo(cache.getMissCount()));
-        assertThat(cache.getCacheSize(), equalTo(0L));
-
-        if (executor != null) {
-            ThreadPool.terminate(executor, 10, TimeUnit.SECONDS);
-        }
-
-        IOUtils.close(reader, dir);
-        dir = null;
-        reader = null;
-        searcher = null;
-    }
-
-    public void testBasic() throws IOException {
-        QueryProfiler profiler = new QueryProfiler(executor != null);
-        searcher.setProfiler(profiler);
-        Query query = new TermQuery(new Term("foo", "bar"));
-        searcher.search(query, 1);
-        List<ProfileResult> results = profiler.getTree();
-        assertEquals(1, results.size());
-        Map<String, Long> breakdown = results.get(0).getTimeBreakdown();
-        assertThat(breakdown.get(QueryTimingType.CREATE_WEIGHT.toString()), greaterThan(0L));
-        assertThat(breakdown.get(QueryTimingType.BUILD_SCORER.toString()), greaterThan(0L));
-        assertThat(breakdown.get(QueryTimingType.NEXT_DOC.toString()), greaterThan(0L));
-        assertThat(breakdown.get(QueryTimingType.ADVANCE.toString()), equalTo(0L));
-        assertThat(breakdown.get(QueryTimingType.SCORE.toString()), greaterThan(0L));
-        assertThat(breakdown.get(QueryTimingType.MATCH.toString()), equalTo(0L));
-
-        assertThat(breakdown.get(QueryTimingType.CREATE_WEIGHT.toString() + "_count"), greaterThan(0L));
-        assertThat(breakdown.get(QueryTimingType.BUILD_SCORER.toString() + "_count"), greaterThan(0L));
-        assertThat(breakdown.get(QueryTimingType.NEXT_DOC.toString() + "_count"), greaterThan(0L));
-        assertThat(breakdown.get(QueryTimingType.ADVANCE.toString() + "_count"), equalTo(0L));
-        assertThat(breakdown.get(QueryTimingType.SCORE.toString() + "_count"), greaterThan(0L));
-        assertThat(breakdown.get(QueryTimingType.MATCH.toString() + "_count"), equalTo(0L));
-
-        long rewriteTime = profiler.getRewriteTime();
-        assertThat(rewriteTime, greaterThan(0L));
-    }
-
-    public void testNoScoring() throws IOException {
-        QueryProfiler profiler = new QueryProfiler(executor != null);
-        searcher.setProfiler(profiler);
-        Query query = new TermQuery(new Term("foo", "bar"));
-        searcher.search(query, 1, Sort.INDEXORDER); // scores are not needed
-        List<ProfileResult> results = profiler.getTree();
-        assertEquals(1, results.size());
-        Map<String, Long> breakdown = results.get(0).getTimeBreakdown();
-        assertThat(breakdown.get(QueryTimingType.CREATE_WEIGHT.toString()), greaterThan(0L));
-        assertThat(breakdown.get(QueryTimingType.BUILD_SCORER.toString()), greaterThan(0L));
-        assertThat(breakdown.get(QueryTimingType.NEXT_DOC.toString()), greaterThan(0L));
-        assertThat(breakdown.get(QueryTimingType.ADVANCE.toString()), equalTo(0L));
-        assertThat(breakdown.get(QueryTimingType.SCORE.toString()), equalTo(0L));
-        assertThat(breakdown.get(QueryTimingType.MATCH.toString()), equalTo(0L));
-
-        assertThat(breakdown.get(QueryTimingType.CREATE_WEIGHT.toString() + "_count"), greaterThan(0L));
-        assertThat(breakdown.get(QueryTimingType.BUILD_SCORER.toString() + "_count"), greaterThan(0L));
-        assertThat(breakdown.get(QueryTimingType.NEXT_DOC.toString() + "_count"), greaterThan(0L));
-        assertThat(breakdown.get(QueryTimingType.ADVANCE.toString() + "_count"), equalTo(0L));
-        assertThat(breakdown.get(QueryTimingType.SCORE.toString() + "_count"), equalTo(0L));
-        assertThat(breakdown.get(QueryTimingType.MATCH.toString() + "_count"), equalTo(0L));
-
-        long rewriteTime = profiler.getRewriteTime();
-        assertThat(rewriteTime, greaterThan(0L));
-    }
-
-    public void testUseIndexStats() throws IOException {
-        QueryProfiler profiler = new QueryProfiler(executor != null);
-        searcher.setProfiler(profiler);
-        Query query = new TermQuery(new Term("foo", "bar"));
-        searcher.count(query); // will use index stats
-        List<ProfileResult> results = profiler.getTree();
-        assertEquals(1, results.size());
-        ProfileResult result = results.get(0);
-        assertEquals(0, (long) result.getTimeBreakdown().get("build_scorer_count"));
-
-        long rewriteTime = profiler.getRewriteTime();
-        assertThat(rewriteTime, greaterThan(0L));
-    }
-
-    public void testApproximations() throws IOException {
-        QueryProfiler profiler = new QueryProfiler(executor != null);
-        searcher.setProfiler(profiler);
-        Query query = new RandomApproximationQuery(new TermQuery(new Term("foo", "bar")), random());
-        searcher.count(query);
-        List<ProfileResult> results = profiler.getTree();
-        assertEquals(1, results.size());
-        Map<String, Long> breakdown = results.get(0).getTimeBreakdown();
-        assertThat(breakdown.get(QueryTimingType.CREATE_WEIGHT.toString()), greaterThan(0L));
-        assertThat(breakdown.get(QueryTimingType.BUILD_SCORER.toString()), greaterThan(0L));
-        assertThat(breakdown.get(QueryTimingType.NEXT_DOC.toString()), greaterThan(0L));
-        assertThat(breakdown.get(QueryTimingType.ADVANCE.toString()), equalTo(0L));
-        assertThat(breakdown.get(QueryTimingType.SCORE.toString()), equalTo(0L));
-        assertThat(breakdown.get(QueryTimingType.MATCH.toString()), greaterThan(0L));
-
-        assertThat(breakdown.get(QueryTimingType.CREATE_WEIGHT.toString() + "_count"), greaterThan(0L));
-        assertThat(breakdown.get(QueryTimingType.BUILD_SCORER.toString() + "_count"), greaterThan(0L));
-        assertThat(breakdown.get(QueryTimingType.NEXT_DOC.toString() + "_count"), greaterThan(0L));
-        assertThat(breakdown.get(QueryTimingType.ADVANCE.toString() + "_count"), equalTo(0L));
-        assertThat(breakdown.get(QueryTimingType.SCORE.toString() + "_count"), equalTo(0L));
-        assertThat(breakdown.get(QueryTimingType.MATCH.toString() + "_count"), greaterThan(0L));
-
-        long rewriteTime = profiler.getRewriteTime();
-        assertThat(rewriteTime, greaterThan(0L));
-    }
-
-    public void testCollector() throws IOException {
-        TotalHitCountCollector collector = new TotalHitCountCollector();
-        ProfileCollector profileCollector = new ProfileCollector(collector);
-        assertEquals(0, profileCollector.getTime());
-        final LeafCollector leafCollector = profileCollector.getLeafCollector(reader.leaves().get(0));
-        assertThat(profileCollector.getTime(), greaterThan(0L));
-        long time = profileCollector.getTime();
-        leafCollector.setScorer(null);
-        assertThat(profileCollector.getTime(), greaterThan(time));
-        time = profileCollector.getTime();
-        leafCollector.collect(0);
-        assertThat(profileCollector.getTime(), greaterThan(time));
-    }
-
-    private static class DummyQuery extends Query {
-
-        @Override
-        public String toString(String field) {
-            return getClass().getSimpleName();
-        }
-
-        @Override
-        public boolean equals(Object obj) {
-            return this == obj;
-        }
-
-        @Override
-        public int hashCode() {
-            return 0;
-        }
-
-        @Override
-        public Weight createWeight(IndexSearcher searcher, ScoreMode scoreMode, float boost) throws IOException {
-            return new Weight(this) {
-                @Override
-                public Explanation explain(LeafReaderContext context, int doc) throws IOException {
-                    throw new UnsupportedOperationException();
-                }
-
-                @Override
-                public Scorer scorer(LeafReaderContext context) throws IOException {
-                    throw new UnsupportedOperationException();
-                }
-
-                @Override
-                public ScorerSupplier scorerSupplier(LeafReaderContext context) throws IOException {
-                    return new ScorerSupplier() {
-
-                        @Override
-                        public Scorer get(long loadCost) throws IOException {
-                            throw new UnsupportedOperationException();
-                        }
-
-                        @Override
-                        public long cost() {
-                            return 42;
-                        }
-                    };
-                }
-
-                @Override
-                public boolean isCacheable(LeafReaderContext ctx) {
-                    return true;
-                }
-            };
-        }
-
-        @Override
-        public void visit(QueryVisitor visitor) {
-            visitor.visitLeaf(this);
-        }
-    }
-
-    public void testScorerSupplier() throws IOException {
-        Directory dir = newDirectory();
-        IndexWriter w = new IndexWriter(dir, newIndexWriterConfig());
-        w.addDocument(new Document());
-        DirectoryReader reader = DirectoryReader.open(w);
-        w.close();
-        IndexSearcher s = newSearcher(reader);
-        s.setQueryCache(null);
-        Weight weight = s.createWeight(s.rewrite(new DummyQuery()), randomFrom(ScoreMode.values()), 1f);
-        // exception when getting the scorer
-        expectThrows(UnsupportedOperationException.class, () -> weight.scorer(s.getIndexReader().leaves().get(0)));
-        // no exception, means scorerSupplier is delegated
-        weight.scorerSupplier(s.getIndexReader().leaves().get(0));
-        reader.close();
-        dir.close();
-    }
-
-    private static final QueryCachingPolicy ALWAYS_CACHE_POLICY = new QueryCachingPolicy() {
-
-        @Override
-        public void onUse(Query query) {}
-
-        @Override
-        public boolean shouldCache(Query query) throws IOException {
-            return true;
-        }
-
-    };
-}
diff --git a/sandbox/plugins/concurrent-search/src/test/java/org/opensearch/search/query/QueryPhaseTests.java b/sandbox/plugins/concurrent-search/src/test/java/org/opensearch/search/query/QueryPhaseTests.java
deleted file mode 100644
index 2b4ad8f0a26bd..0000000000000
--- a/sandbox/plugins/concurrent-search/src/test/java/org/opensearch/search/query/QueryPhaseTests.java
+++ /dev/null
@@ -1,1261 +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.
- */
-
-/*
- * 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.search.query;
-
-import com.carrotsearch.randomizedtesting.annotations.ParametersFactory;
-import org.apache.lucene.analysis.standard.StandardAnalyzer;
-import org.apache.lucene.document.Document;
-import org.apache.lucene.document.Field.Store;
-import org.apache.lucene.document.LatLonDocValuesField;
-import org.apache.lucene.document.LatLonPoint;
-import org.apache.lucene.document.LongPoint;
-import org.apache.lucene.document.NumericDocValuesField;
-import org.apache.lucene.document.SortedDocValuesField;
-import org.apache.lucene.document.SortedSetDocValuesField;
-import org.apache.lucene.document.StringField;
-import org.apache.lucene.document.TextField;
-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.index.NoMergePolicy;
-import org.apache.lucene.index.Term;
-import org.apache.lucene.queries.spans.SpanNearQuery;
-import org.apache.lucene.queries.spans.SpanTermQuery;
-import org.apache.lucene.search.BooleanClause.Occur;
-import org.apache.lucene.search.BooleanQuery;
-import org.apache.lucene.search.Collector;
-import org.apache.lucene.search.ConstantScoreQuery;
-import org.apache.lucene.search.DocValuesFieldExistsQuery;
-import org.apache.lucene.search.FieldComparator;
-import org.apache.lucene.search.FieldDoc;
-import org.apache.lucene.search.FilterCollector;
-import org.apache.lucene.search.FilterLeafCollector;
-import org.apache.lucene.search.IndexSearcher;
-import org.apache.lucene.search.LeafCollector;
-import org.apache.lucene.search.MatchAllDocsQuery;
-import org.apache.lucene.search.MatchNoDocsQuery;
-import org.apache.lucene.search.MultiTermQuery;
-import org.apache.lucene.search.PrefixQuery;
-import org.apache.lucene.search.Query;
-import org.apache.lucene.search.ScoreDoc;
-import org.apache.lucene.search.Sort;
-import org.apache.lucene.search.SortField;
-import org.apache.lucene.search.TermQuery;
-import org.apache.lucene.search.TopDocs;
-import org.apache.lucene.search.TotalHitCountCollector;
-import org.apache.lucene.search.TotalHits;
-import org.apache.lucene.search.Weight;
-import org.apache.lucene.search.grouping.CollapseTopFieldDocs;
-import org.apache.lucene.search.join.BitSetProducer;
-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.BytesRef;
-import org.apache.lucene.util.FixedBitSet;
-import org.opensearch.action.search.SearchShardTask;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.index.mapper.DateFieldMapper;
-import org.opensearch.index.mapper.MappedFieldType;
-import org.opensearch.index.mapper.MapperService;
-import org.opensearch.index.mapper.NumberFieldMapper;
-import org.opensearch.index.mapper.NumberFieldMapper.NumberFieldType;
-import org.opensearch.index.mapper.NumberFieldMapper.NumberType;
-import org.opensearch.index.query.ParsedQuery;
-import org.opensearch.index.query.QueryShardContext;
-import org.opensearch.index.search.OpenSearchToParentBlockJoinQuery;
-import org.opensearch.index.shard.IndexShard;
-import org.opensearch.index.shard.IndexShardTestCase;
-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.sort.SortAndFormats;
-import org.opensearch.tasks.TaskCancelledException;
-import org.opensearch.test.TestSearchContext;
-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.List;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.TimeUnit;
-
-import static org.hamcrest.Matchers.anyOf;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.greaterThan;
-import static org.hamcrest.Matchers.greaterThanOrEqualTo;
-import static org.hamcrest.Matchers.instanceOf;
-import static org.hamcrest.Matchers.lessThanOrEqualTo;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.when;
-import static org.opensearch.search.query.TopDocsCollectorContext.hasInfMaxScore;
-
-public class QueryPhaseTests extends IndexShardTestCase {
-
-    private IndexShard indexShard;
-    private final ExecutorService executor;
-    private final QueryPhaseSearcher queryPhaseSearcher;
-
-    @ParametersFactory
-    public static Collection<Object[]> concurrency() {
-        return Arrays.asList(
-            new Object[] { 0, QueryPhase.DEFAULT_QUERY_PHASE_SEARCHER },
-            new Object[] { 5, new ConcurrentQueryPhaseSearcher() }
-        );
-    }
-
-    public QueryPhaseTests(int concurrency, QueryPhaseSearcher queryPhaseSearcher) {
-        this.executor = (concurrency > 0) ? Executors.newFixedThreadPool(concurrency) : null;
-        this.queryPhaseSearcher = queryPhaseSearcher;
-    }
-
-    @Override
-    public Settings threadPoolSettings() {
-        return Settings.builder().put(super.threadPoolSettings()).put("thread_pool.search.min_queue_size", 10).build();
-    }
-
-    @Override
-    public void setUp() throws Exception {
-        super.setUp();
-        indexShard = newShard(true);
-    }
-
-    @Override
-    public void tearDown() throws Exception {
-        super.tearDown();
-        closeShards(indexShard);
-
-        if (executor != null) {
-            ThreadPool.terminate(executor, 10, TimeUnit.SECONDS);
-        }
-    }
-
-    private void countTestCase(Query query, IndexReader reader, boolean shouldCollectSearch, boolean shouldCollectCount) throws Exception {
-        ContextIndexSearcher searcher = shouldCollectSearch
-            ? newContextSearcher(reader, executor)
-            : newEarlyTerminationContextSearcher(reader, 0, executor);
-        TestSearchContext context = new TestSearchContext(null, indexShard, searcher);
-        context.parsedQuery(new ParsedQuery(query));
-        context.setSize(0);
-        context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-        final boolean rescore = QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-        assertFalse(rescore);
-
-        ContextIndexSearcher countSearcher = shouldCollectCount
-            ? newContextSearcher(reader, executor)
-            : newEarlyTerminationContextSearcher(reader, 0, executor);
-        assertEquals(countSearcher.count(query), context.queryResult().topDocs().topDocs.totalHits.value);
-    }
-
-    private void countTestCase(boolean withDeletions) throws Exception {
-        Directory dir = newDirectory();
-        IndexWriterConfig iwc = newIndexWriterConfig().setMergePolicy(NoMergePolicy.INSTANCE);
-        RandomIndexWriter w = new RandomIndexWriter(random(), dir, iwc);
-        final int numDocs = scaledRandomIntBetween(600, 900);
-        for (int i = 0; i < numDocs; ++i) {
-            Document doc = new Document();
-            if (randomBoolean()) {
-                doc.add(new StringField("foo", "bar", Store.NO));
-                doc.add(new SortedSetDocValuesField("foo", new BytesRef("bar")));
-                doc.add(new SortedSetDocValuesField("docValuesOnlyField", new BytesRef("bar")));
-                doc.add(new LatLonDocValuesField("latLonDVField", 1.0, 1.0));
-                doc.add(new LatLonPoint("latLonDVField", 1.0, 1.0));
-            }
-            if (randomBoolean()) {
-                doc.add(new StringField("foo", "baz", Store.NO));
-                doc.add(new SortedSetDocValuesField("foo", new BytesRef("baz")));
-            }
-            if (withDeletions && (rarely() || i == 0)) {
-                doc.add(new StringField("delete", "yes", Store.NO));
-            }
-            w.addDocument(doc);
-        }
-        if (withDeletions) {
-            w.deleteDocuments(new Term("delete", "yes"));
-        }
-        final IndexReader reader = w.getReader();
-        Query matchAll = new MatchAllDocsQuery();
-        Query matchAllCsq = new ConstantScoreQuery(matchAll);
-        Query tq = new TermQuery(new Term("foo", "bar"));
-        Query tCsq = new ConstantScoreQuery(tq);
-        Query dvfeq = new DocValuesFieldExistsQuery("foo");
-        Query dvfeq_points = new DocValuesFieldExistsQuery("latLonDVField");
-        Query dvfeqCsq = new ConstantScoreQuery(dvfeq);
-        // field with doc-values but not indexed will need to collect
-        Query dvOnlyfeq = new DocValuesFieldExistsQuery("docValuesOnlyField");
-        BooleanQuery bq = new BooleanQuery.Builder().add(matchAll, Occur.SHOULD).add(tq, Occur.MUST).build();
-
-        countTestCase(matchAll, reader, false, false);
-        countTestCase(matchAllCsq, reader, false, false);
-        countTestCase(tq, reader, withDeletions, withDeletions);
-        countTestCase(tCsq, reader, withDeletions, withDeletions);
-        countTestCase(dvfeq, reader, withDeletions, true);
-        countTestCase(dvfeq_points, reader, withDeletions, true);
-        countTestCase(dvfeqCsq, reader, withDeletions, true);
-        countTestCase(dvOnlyfeq, reader, true, true);
-        countTestCase(bq, reader, true, true);
-        reader.close();
-        w.close();
-        dir.close();
-    }
-
-    public void testCountWithoutDeletions() throws Exception {
-        countTestCase(false);
-    }
-
-    public void testCountWithDeletions() throws Exception {
-        countTestCase(true);
-    }
-
-    public void testPostFilterDisablesCountOptimization() throws Exception {
-        Directory dir = newDirectory();
-        final Sort sort = new Sort(new SortField("rank", SortField.Type.INT));
-        IndexWriterConfig iwc = newIndexWriterConfig().setIndexSort(sort);
-        RandomIndexWriter w = new RandomIndexWriter(random(), dir, iwc);
-        Document doc = new Document();
-        w.addDocument(doc);
-        w.close();
-
-        IndexReader reader = DirectoryReader.open(dir);
-
-        TestSearchContext context = new TestSearchContext(null, indexShard, newEarlyTerminationContextSearcher(reader, 0, executor));
-        context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-        context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
-
-        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-        assertEquals(1, context.queryResult().topDocs().topDocs.totalHits.value);
-
-        context.setSearcher(newContextSearcher(reader, executor));
-        context.parsedPostFilter(new ParsedQuery(new MatchNoDocsQuery()));
-        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-        assertEquals(0, context.queryResult().topDocs().topDocs.totalHits.value);
-        reader.close();
-        dir.close();
-    }
-
-    public void testTerminateAfterWithFilter() throws Exception {
-        Directory dir = newDirectory();
-        final Sort sort = new Sort(new SortField("rank", SortField.Type.INT));
-        IndexWriterConfig iwc = newIndexWriterConfig().setIndexSort(sort);
-        RandomIndexWriter w = new RandomIndexWriter(random(), dir, iwc);
-        Document doc = new Document();
-        for (int i = 0; i < 10; i++) {
-            doc.add(new StringField("foo", Integer.toString(i), Store.NO));
-        }
-        w.addDocument(doc);
-        w.close();
-
-        IndexReader reader = DirectoryReader.open(dir);
-
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor));
-        context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-
-        context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
-        context.terminateAfter(1);
-        context.setSize(10);
-        for (int i = 0; i < 10; i++) {
-            context.parsedPostFilter(new ParsedQuery(new TermQuery(new Term("foo", Integer.toString(i)))));
-            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-            assertEquals(1, context.queryResult().topDocs().topDocs.totalHits.value);
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
-        }
-        reader.close();
-        dir.close();
-    }
-
-    public void testMinScoreDisablesCountOptimization() throws Exception {
-        Directory dir = newDirectory();
-        final Sort sort = new Sort(new SortField("rank", SortField.Type.INT));
-        IndexWriterConfig iwc = newIndexWriterConfig().setIndexSort(sort);
-        RandomIndexWriter w = new RandomIndexWriter(random(), dir, iwc);
-        Document doc = new Document();
-        w.addDocument(doc);
-        w.close();
-
-        IndexReader reader = DirectoryReader.open(dir);
-        TestSearchContext context = new TestSearchContext(null, indexShard, newEarlyTerminationContextSearcher(reader, 0, executor));
-        context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
-        context.setSize(0);
-        context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-        assertEquals(1, context.queryResult().topDocs().topDocs.totalHits.value);
-
-        context.minimumScore(100);
-        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-        assertEquals(0, context.queryResult().topDocs().topDocs.totalHits.value);
-        assertEquals(TotalHits.Relation.EQUAL_TO, context.queryResult().topDocs().topDocs.totalHits.relation);
-        reader.close();
-        dir.close();
-    }
-
-    public void testQueryCapturesThreadPoolStats() throws Exception {
-        Directory dir = newDirectory();
-        IndexWriterConfig iwc = newIndexWriterConfig();
-        RandomIndexWriter w = new RandomIndexWriter(random(), dir, iwc);
-        final int numDocs = scaledRandomIntBetween(600, 900);
-        for (int i = 0; i < numDocs; ++i) {
-            w.addDocument(new Document());
-        }
-        w.close();
-        IndexReader reader = DirectoryReader.open(dir);
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor));
-        context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-        context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
-
-        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-        QuerySearchResult results = context.queryResult();
-        assertThat(results.serviceTimeEWMA(), greaterThanOrEqualTo(0L));
-        assertThat(results.nodeQueueSize(), greaterThanOrEqualTo(0));
-        reader.close();
-        dir.close();
-    }
-
-    public void testInOrderScrollOptimization() throws Exception {
-        Directory dir = newDirectory();
-        final Sort sort = new Sort(new SortField("rank", SortField.Type.INT));
-        IndexWriterConfig iwc = newIndexWriterConfig().setIndexSort(sort);
-        RandomIndexWriter w = new RandomIndexWriter(random(), dir, iwc);
-        final int numDocs = scaledRandomIntBetween(600, 900);
-        for (int i = 0; i < numDocs; ++i) {
-            w.addDocument(new Document());
-        }
-        w.close();
-        IndexReader reader = DirectoryReader.open(dir);
-        ScrollContext scrollContext = new ScrollContext();
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor), scrollContext);
-        context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
-        context.sort(new SortAndFormats(sort, new DocValueFormat[] { DocValueFormat.RAW }));
-        scrollContext.lastEmittedDoc = null;
-        scrollContext.maxScore = Float.NaN;
-        scrollContext.totalHits = null;
-        context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-        int size = randomIntBetween(2, 5);
-        context.setSize(size);
-
-        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-        assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
-        assertNull(context.queryResult().terminatedEarly());
-        assertThat(context.terminateAfter(), equalTo(0));
-        assertThat(context.queryResult().getTotalHits().value, equalTo((long) numDocs));
-
-        context.setSearcher(newEarlyTerminationContextSearcher(reader, size, executor));
-        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-        assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
-        assertThat(context.queryResult().getTotalHits().value, equalTo((long) numDocs));
-        assertThat(context.queryResult().topDocs().topDocs.scoreDocs[0].doc, greaterThanOrEqualTo(size));
-        reader.close();
-        dir.close();
-    }
-
-    public void testTerminateAfterEarlyTermination() throws Exception {
-        Directory dir = newDirectory();
-        IndexWriterConfig iwc = newIndexWriterConfig();
-        RandomIndexWriter w = new RandomIndexWriter(random(), dir, iwc);
-        final int numDocs = scaledRandomIntBetween(600, 900);
-        for (int i = 0; i < numDocs; ++i) {
-            Document doc = new Document();
-            if (randomBoolean()) {
-                doc.add(new StringField("foo", "bar", Store.NO));
-            }
-            if (randomBoolean()) {
-                doc.add(new StringField("foo", "baz", Store.NO));
-            }
-            doc.add(new NumericDocValuesField("rank", numDocs - i));
-            w.addDocument(doc);
-        }
-        w.close();
-        final IndexReader reader = DirectoryReader.open(dir);
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor));
-        context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-        context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
-
-        context.terminateAfter(numDocs);
-        {
-            context.setSize(10);
-            final TestTotalHitCountCollectorManager manager = TestTotalHitCountCollectorManager.create(executor);
-            context.queryCollectorManagers().put(TotalHitCountCollector.class, manager);
-            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-            assertFalse(context.queryResult().terminatedEarly());
-            assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(10));
-            assertThat(manager.getTotalHits(), equalTo(numDocs));
-        }
-
-        context.terminateAfter(1);
-        {
-            context.setSize(1);
-            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-            assertTrue(context.queryResult().terminatedEarly());
-            assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(1L));
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
-
-            context.setSize(0);
-            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-            assertTrue(context.queryResult().terminatedEarly());
-            assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(1L));
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(0));
-        }
-
-        {
-            context.setSize(1);
-            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-            assertTrue(context.queryResult().terminatedEarly());
-            assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(1L));
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
-        }
-        {
-            context.setSize(1);
-            BooleanQuery bq = new BooleanQuery.Builder().add(new TermQuery(new Term("foo", "bar")), Occur.SHOULD)
-                .add(new TermQuery(new Term("foo", "baz")), Occur.SHOULD)
-                .build();
-            context.parsedQuery(new ParsedQuery(bq));
-            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-            assertTrue(context.queryResult().terminatedEarly());
-            assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(1L));
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
-
-            context.setSize(0);
-            context.parsedQuery(new ParsedQuery(bq));
-            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-            assertTrue(context.queryResult().terminatedEarly());
-            assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(1L));
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(0));
-        }
-        {
-            context.setSize(1);
-            final TestTotalHitCountCollectorManager manager = TestTotalHitCountCollectorManager.create(executor, 1);
-            context.queryCollectorManagers().put(TotalHitCountCollector.class, manager);
-            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-            assertTrue(context.queryResult().terminatedEarly());
-            assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(1L));
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
-            assertThat(manager.getTotalHits(), equalTo(1));
-            context.queryCollectorManagers().clear();
-        }
-        {
-            context.setSize(0);
-            final TestTotalHitCountCollectorManager manager = TestTotalHitCountCollectorManager.create(executor, 1);
-            context.queryCollectorManagers().put(TotalHitCountCollector.class, manager);
-            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-            assertTrue(context.queryResult().terminatedEarly());
-            assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(1L));
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(0));
-            assertThat(manager.getTotalHits(), equalTo(1));
-        }
-
-        // tests with trackTotalHits and terminateAfter
-        context.terminateAfter(10);
-        context.setSize(0);
-        for (int trackTotalHits : new int[] { -1, 3, 76, 100 }) {
-            context.trackTotalHitsUpTo(trackTotalHits);
-            final TestTotalHitCountCollectorManager manager = TestTotalHitCountCollectorManager.create(executor);
-            context.queryCollectorManagers().put(TotalHitCountCollector.class, manager);
-            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-            assertTrue(context.queryResult().terminatedEarly());
-            if (trackTotalHits == -1) {
-                assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(0L));
-            } else {
-                assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) Math.min(trackTotalHits, 10)));
-            }
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(0));
-            // The concurrent search terminates the collection when the number of hits is reached by each
-            // concurrent collector. In this case, in general, the number of results are multiplied by the number of
-            // slices (as the unit of concurrency). To address that, we have to use the shared global state,
-            // much as HitsThresholdChecker does.
-            if (executor == null) {
-                assertThat(manager.getTotalHits(), equalTo(10));
-            }
-        }
-
-        context.terminateAfter(7);
-        context.setSize(10);
-        for (int trackTotalHits : new int[] { -1, 3, 75, 100 }) {
-            context.trackTotalHitsUpTo(trackTotalHits);
-            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-            assertTrue(context.queryResult().terminatedEarly());
-            if (trackTotalHits == -1) {
-                assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(0L));
-            } else {
-                assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(7L));
-            }
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(7));
-        }
-        reader.close();
-        dir.close();
-    }
-
-    public void testIndexSortingEarlyTermination() throws Exception {
-        Directory dir = newDirectory();
-        final Sort sort = new Sort(new SortField("rank", SortField.Type.INT));
-        IndexWriterConfig iwc = newIndexWriterConfig().setIndexSort(sort);
-        RandomIndexWriter w = new RandomIndexWriter(random(), dir, iwc);
-        final int numDocs = scaledRandomIntBetween(600, 900);
-        for (int i = 0; i < numDocs; ++i) {
-            Document doc = new Document();
-            if (randomBoolean()) {
-                doc.add(new StringField("foo", "bar", Store.NO));
-            }
-            if (randomBoolean()) {
-                doc.add(new StringField("foo", "baz", Store.NO));
-            }
-            doc.add(new NumericDocValuesField("rank", numDocs - i));
-            w.addDocument(doc);
-        }
-        w.close();
-
-        final IndexReader reader = DirectoryReader.open(dir);
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor));
-        context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
-        context.setSize(1);
-        context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-        context.sort(new SortAndFormats(sort, new DocValueFormat[] { DocValueFormat.RAW }));
-
-        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-        assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
-        assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
-        assertThat(context.queryResult().topDocs().topDocs.scoreDocs[0], instanceOf(FieldDoc.class));
-        FieldDoc fieldDoc = (FieldDoc) context.queryResult().topDocs().topDocs.scoreDocs[0];
-        assertThat(fieldDoc.fields[0], equalTo(1));
-
-        {
-            context.parsedPostFilter(new ParsedQuery(new MinDocQuery(1)));
-            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-            assertNull(context.queryResult().terminatedEarly());
-            assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(numDocs - 1L));
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs[0], instanceOf(FieldDoc.class));
-            assertThat(fieldDoc.fields[0], anyOf(equalTo(1), equalTo(2)));
-            context.parsedPostFilter(null);
-
-            final TestTotalHitCountCollectorManager manager = TestTotalHitCountCollectorManager.create(executor, sort);
-            context.queryCollectorManagers().put(TotalHitCountCollector.class, manager);
-            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-            assertNull(context.queryResult().terminatedEarly());
-            assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs[0], instanceOf(FieldDoc.class));
-            assertThat(fieldDoc.fields[0], anyOf(equalTo(1), equalTo(2)));
-            // When searching concurrently, each executors short-circuits when "size" is reached,
-            // including total hits collector
-            assertThat(manager.getTotalHits(), lessThanOrEqualTo(numDocs));
-
-            context.queryCollectorManagers().clear();
-        }
-
-        {
-            context.setSearcher(newEarlyTerminationContextSearcher(reader, 1, executor));
-            context.trackTotalHitsUpTo(SearchContext.TRACK_TOTAL_HITS_DISABLED);
-            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-            assertNull(context.queryResult().terminatedEarly());
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs[0], instanceOf(FieldDoc.class));
-            assertThat(fieldDoc.fields[0], anyOf(equalTo(1), equalTo(2)));
-
-            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-            assertNull(context.queryResult().terminatedEarly());
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs[0], instanceOf(FieldDoc.class));
-            assertThat(fieldDoc.fields[0], anyOf(equalTo(1), equalTo(2)));
-        }
-        reader.close();
-        dir.close();
-    }
-
-    public void testIndexSortScrollOptimization() throws Exception {
-        Directory dir = newDirectory();
-        final Sort indexSort = new Sort(new SortField("rank", SortField.Type.INT), new SortField("tiebreaker", SortField.Type.INT));
-        IndexWriterConfig iwc = newIndexWriterConfig().setIndexSort(indexSort);
-        RandomIndexWriter w = new RandomIndexWriter(random(), dir, iwc);
-        final int numDocs = scaledRandomIntBetween(600, 900);
-        for (int i = 0; i < numDocs; ++i) {
-            Document doc = new Document();
-            doc.add(new NumericDocValuesField("rank", random().nextInt()));
-            doc.add(new NumericDocValuesField("tiebreaker", i));
-            w.addDocument(doc);
-        }
-        if (randomBoolean()) {
-            w.forceMerge(randomIntBetween(1, 10));
-        }
-        w.close();
-
-        final IndexReader reader = DirectoryReader.open(dir);
-        List<SortAndFormats> searchSortAndFormats = new ArrayList<>();
-        searchSortAndFormats.add(new SortAndFormats(indexSort, new DocValueFormat[] { DocValueFormat.RAW, DocValueFormat.RAW }));
-        // search sort is a prefix of the index sort
-        searchSortAndFormats.add(new SortAndFormats(new Sort(indexSort.getSort()[0]), new DocValueFormat[] { DocValueFormat.RAW }));
-        for (SortAndFormats searchSortAndFormat : searchSortAndFormats) {
-            ScrollContext scrollContext = new ScrollContext();
-            TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor), scrollContext);
-            context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
-            scrollContext.lastEmittedDoc = null;
-            scrollContext.maxScore = Float.NaN;
-            scrollContext.totalHits = null;
-            context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-            context.setSize(10);
-            context.sort(searchSortAndFormat);
-
-            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-            assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
-            assertNull(context.queryResult().terminatedEarly());
-            assertThat(context.terminateAfter(), equalTo(0));
-            assertThat(context.queryResult().getTotalHits().value, equalTo((long) numDocs));
-            int sizeMinus1 = context.queryResult().topDocs().topDocs.scoreDocs.length - 1;
-            FieldDoc lastDoc = (FieldDoc) context.queryResult().topDocs().topDocs.scoreDocs[sizeMinus1];
-
-            context.setSearcher(newEarlyTerminationContextSearcher(reader, 10, executor));
-            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-            assertNull(context.queryResult().terminatedEarly());
-            assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
-            assertThat(context.terminateAfter(), equalTo(0));
-            assertThat(context.queryResult().getTotalHits().value, equalTo((long) numDocs));
-            FieldDoc firstDoc = (FieldDoc) context.queryResult().topDocs().topDocs.scoreDocs[0];
-            for (int i = 0; i < searchSortAndFormat.sort.getSort().length; i++) {
-                @SuppressWarnings("unchecked")
-                FieldComparator<Object> comparator = (FieldComparator<Object>) searchSortAndFormat.sort.getSort()[i].getComparator(
-                    i,
-                    false
-                );
-                int cmp = comparator.compareValues(firstDoc.fields[i], lastDoc.fields[i]);
-                if (cmp == 0) {
-                    continue;
-                }
-                assertThat(cmp, equalTo(1));
-                break;
-            }
-        }
-        reader.close();
-        dir.close();
-    }
-
-    public void testDisableTopScoreCollection() throws Exception {
-        Directory dir = newDirectory();
-        IndexWriterConfig iwc = newIndexWriterConfig(new StandardAnalyzer());
-        RandomIndexWriter w = new RandomIndexWriter(random(), dir, iwc);
-        Document doc = new Document();
-        final int numDocs = 2 * scaledRandomIntBetween(50, 450);
-        for (int i = 0; i < numDocs; i++) {
-            doc.clear();
-            if (i % 2 == 0) {
-                doc.add(new TextField("title", "foo bar", Store.NO));
-            } else {
-                doc.add(new TextField("title", "foo", Store.NO));
-            }
-            w.addDocument(doc);
-        }
-        w.close();
-
-        IndexReader reader = DirectoryReader.open(dir);
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor));
-        context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-        Query q = new SpanNearQuery.Builder("title", true).addClause(new SpanTermQuery(new Term("title", "foo")))
-            .addClause(new SpanTermQuery(new Term("title", "bar")))
-            .build();
-
-        context.parsedQuery(new ParsedQuery(q));
-        context.setSize(3);
-        context.trackTotalHitsUpTo(3);
-        TopDocsCollectorContext topDocsContext = TopDocsCollectorContext.createTopDocsCollectorContext(context, false);
-        assertEquals(topDocsContext.create(null).scoreMode(), org.apache.lucene.search.ScoreMode.COMPLETE);
-        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-        assertEquals(numDocs / 2, context.queryResult().topDocs().topDocs.totalHits.value);
-        assertEquals(context.queryResult().topDocs().topDocs.totalHits.relation, TotalHits.Relation.EQUAL_TO);
-        assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(3));
-
-        context.sort(new SortAndFormats(new Sort(new SortField("other", SortField.Type.INT)), new DocValueFormat[] { DocValueFormat.RAW }));
-        topDocsContext = TopDocsCollectorContext.createTopDocsCollectorContext(context, false);
-        assertEquals(topDocsContext.create(null).scoreMode(), org.apache.lucene.search.ScoreMode.TOP_DOCS);
-        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-        assertEquals(numDocs / 2, context.queryResult().topDocs().topDocs.totalHits.value);
-        assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(3));
-        assertEquals(context.queryResult().topDocs().topDocs.totalHits.relation, TotalHits.Relation.GREATER_THAN_OR_EQUAL_TO);
-
-        reader.close();
-        dir.close();
-    }
-
-    public void testEnhanceSortOnNumeric() throws Exception {
-        final String fieldNameLong = "long-field";
-        final String fieldNameDate = "date-field";
-        MappedFieldType fieldTypeLong = new NumberFieldMapper.NumberFieldType(fieldNameLong, NumberFieldMapper.NumberType.LONG);
-        MappedFieldType fieldTypeDate = new DateFieldMapper.DateFieldType(fieldNameDate);
-        MapperService mapperService = mock(MapperService.class);
-        when(mapperService.fieldType(fieldNameLong)).thenReturn(fieldTypeLong);
-        when(mapperService.fieldType(fieldNameDate)).thenReturn(fieldTypeDate);
-        // enough docs to have a tree with several leaf nodes
-        final int numDocs = 3500 * 5;
-        Directory dir = newDirectory();
-        IndexWriter writer = new IndexWriter(dir, new IndexWriterConfig(null));
-        long firstValue = randomLongBetween(-10000000L, 10000000L);
-        long longValue = firstValue;
-        long dateValue = randomLongBetween(0, 3000000000000L);
-        for (int i = 1; i <= numDocs; ++i) {
-            Document doc = new Document();
-
-            doc.add(new LongPoint(fieldNameLong, longValue));
-            doc.add(new NumericDocValuesField(fieldNameLong, longValue));
-
-            doc.add(new LongPoint(fieldNameDate, dateValue));
-            doc.add(new NumericDocValuesField(fieldNameDate, dateValue));
-            writer.addDocument(doc);
-            longValue++;
-            dateValue++;
-            if (i % 3500 == 0) writer.commit();
-        }
-        writer.close();
-        final IndexReader reader = DirectoryReader.open(dir);
-        final SortField sortFieldLong = new SortField(fieldNameLong, SortField.Type.LONG);
-        sortFieldLong.setMissingValue(Long.MAX_VALUE);
-        final SortField sortFieldDate = new SortField(fieldNameDate, SortField.Type.LONG);
-        sortFieldDate.setMissingValue(Long.MAX_VALUE);
-        DocValueFormat dateFormat = fieldTypeDate.docValueFormat(null, null);
-        final Sort longSort = new Sort(sortFieldLong);
-        final Sort longDateSort = new Sort(sortFieldLong, sortFieldDate);
-        final Sort dateSort = new Sort(sortFieldDate);
-        final Sort dateLongSort = new Sort(sortFieldDate, sortFieldLong);
-        SortAndFormats longSortAndFormats = new SortAndFormats(longSort, new DocValueFormat[] { DocValueFormat.RAW });
-        SortAndFormats longDateSortAndFormats = new SortAndFormats(longDateSort, new DocValueFormat[] { DocValueFormat.RAW, dateFormat });
-        SortAndFormats dateSortAndFormats = new SortAndFormats(dateSort, new DocValueFormat[] { dateFormat });
-        SortAndFormats dateLongSortAndFormats = new SortAndFormats(dateLongSort, new DocValueFormat[] { dateFormat, DocValueFormat.RAW });
-        ParsedQuery query = new ParsedQuery(new MatchAllDocsQuery());
-        SearchShardTask task = new SearchShardTask(123L, "", "", "", null, Collections.emptyMap());
-
-        // 1. Test a sort on long field
-        {
-            TestSearchContext searchContext = spy(new TestSearchContext(null, indexShard, newContextSearcher(reader, executor)));
-            when(searchContext.mapperService()).thenReturn(mapperService);
-            searchContext.sort(longSortAndFormats);
-            searchContext.parsedQuery(query);
-            searchContext.setTask(task);
-            searchContext.setSize(10);
-            QueryPhase.executeInternal(searchContext.withCleanQueryResult(), queryPhaseSearcher);
-            assertSortResults(searchContext.queryResult().topDocs().topDocs, (long) numDocs, false);
-        }
-
-        // 2. Test a sort on long field + date field
-        {
-            TestSearchContext searchContext = spy(new TestSearchContext(null, indexShard, newContextSearcher(reader, executor)));
-            when(searchContext.mapperService()).thenReturn(mapperService);
-            searchContext.sort(longDateSortAndFormats);
-            searchContext.parsedQuery(query);
-            searchContext.setTask(task);
-            searchContext.setSize(10);
-            QueryPhase.executeInternal(searchContext.withCleanQueryResult(), queryPhaseSearcher);
-            assertSortResults(searchContext.queryResult().topDocs().topDocs, (long) numDocs, true);
-        }
-
-        // 3. Test a sort on date field
-        {
-            TestSearchContext searchContext = spy(new TestSearchContext(null, indexShard, newContextSearcher(reader, executor)));
-            when(searchContext.mapperService()).thenReturn(mapperService);
-            searchContext.sort(dateSortAndFormats);
-            searchContext.parsedQuery(query);
-            searchContext.setTask(task);
-            searchContext.setSize(10);
-            QueryPhase.executeInternal(searchContext.withCleanQueryResult(), queryPhaseSearcher);
-            assertSortResults(searchContext.queryResult().topDocs().topDocs, (long) numDocs, false);
-        }
-
-        // 4. Test a sort on date field + long field
-        {
-            TestSearchContext searchContext = spy(new TestSearchContext(null, indexShard, newContextSearcher(reader, executor)));
-            when(searchContext.mapperService()).thenReturn(mapperService);
-            searchContext.sort(dateLongSortAndFormats);
-            searchContext.parsedQuery(query);
-            searchContext.setTask(task);
-            searchContext.setSize(10);
-            QueryPhase.executeInternal(searchContext.withCleanQueryResult(), queryPhaseSearcher);
-            assertSortResults(searchContext.queryResult().topDocs().topDocs, (long) numDocs, true);
-        }
-
-        // 5. Test that sort optimization is run when from > 0 and size = 0
-        {
-            TestSearchContext searchContext = spy(new TestSearchContext(null, indexShard, newContextSearcher(reader, executor)));
-            when(searchContext.mapperService()).thenReturn(mapperService);
-            searchContext.sort(longSortAndFormats);
-            searchContext.parsedQuery(query);
-            searchContext.setTask(task);
-            searchContext.from(5);
-            searchContext.setSize(0);
-            QueryPhase.executeInternal(searchContext.withCleanQueryResult(), queryPhaseSearcher);
-            assertSortResults(searchContext.queryResult().topDocs().topDocs, (long) numDocs, false);
-        }
-
-        // 6. Test that sort optimization works with from = 0 and size= 0
-        {
-            TestSearchContext searchContext = spy(new TestSearchContext(null, indexShard, newContextSearcher(reader, executor)));
-            when(searchContext.mapperService()).thenReturn(mapperService);
-            searchContext.sort(longSortAndFormats);
-            searchContext.parsedQuery(query);
-            searchContext.setTask(task);
-            searchContext.setSize(0);
-            QueryPhase.executeInternal(searchContext.withCleanQueryResult(), queryPhaseSearcher);
-        }
-
-        // 7. Test that sort optimization works with search after
-        {
-            TestSearchContext searchContext = spy(new TestSearchContext(null, indexShard, newContextSearcher(reader, executor)));
-            when(searchContext.mapperService()).thenReturn(mapperService);
-            int afterDocument = (int) randomLongBetween(0, 50);
-            long afterValue = firstValue + afterDocument;
-            FieldDoc after = new FieldDoc(afterDocument, Float.NaN, new Long[] { afterValue });
-            searchContext.searchAfter(after);
-            searchContext.sort(longSortAndFormats);
-            searchContext.parsedQuery(query);
-            searchContext.setTask(task);
-            searchContext.setSize(10);
-            QueryPhase.executeInternal(searchContext.withCleanQueryResult(), queryPhaseSearcher);
-            final TopDocs topDocs = searchContext.queryResult().topDocs().topDocs;
-            long topValue = (long) ((FieldDoc) topDocs.scoreDocs[0]).fields[0];
-            assertThat(topValue, greaterThan(afterValue));
-            assertSortResults(topDocs, (long) numDocs, false);
-
-            final TotalHits totalHits = topDocs.totalHits;
-            assertEquals(TotalHits.Relation.EQUAL_TO, totalHits.relation);
-            assertEquals(numDocs, totalHits.value);
-        }
-
-        reader.close();
-        dir.close();
-    }
-
-    public void testMaxScoreQueryVisitor() {
-        BitSetProducer producer = context -> new FixedBitSet(1);
-        Query query = new OpenSearchToParentBlockJoinQuery(new MatchAllDocsQuery(), producer, ScoreMode.Avg, "nested");
-        assertTrue(hasInfMaxScore(query));
-
-        query = new OpenSearchToParentBlockJoinQuery(new MatchAllDocsQuery(), producer, ScoreMode.None, "nested");
-        assertFalse(hasInfMaxScore(query));
-
-        for (Occur occur : Occur.values()) {
-            query = new BooleanQuery.Builder().add(
-                new OpenSearchToParentBlockJoinQuery(new MatchAllDocsQuery(), producer, ScoreMode.Avg, "nested"),
-                occur
-            ).build();
-            if (occur == Occur.MUST) {
-                assertTrue(hasInfMaxScore(query));
-            } else {
-                assertFalse(hasInfMaxScore(query));
-            }
-
-            query = new BooleanQuery.Builder().add(
-                new BooleanQuery.Builder().add(
-                    new OpenSearchToParentBlockJoinQuery(new MatchAllDocsQuery(), producer, ScoreMode.Avg, "nested"),
-                    occur
-                ).build(),
-                occur
-            ).build();
-            if (occur == Occur.MUST) {
-                assertTrue(hasInfMaxScore(query));
-            } else {
-                assertFalse(hasInfMaxScore(query));
-            }
-
-            query = new BooleanQuery.Builder().add(
-                new BooleanQuery.Builder().add(
-                    new OpenSearchToParentBlockJoinQuery(new MatchAllDocsQuery(), producer, ScoreMode.Avg, "nested"),
-                    occur
-                ).build(),
-                Occur.FILTER
-            ).build();
-            assertFalse(hasInfMaxScore(query));
-
-            query = new BooleanQuery.Builder().add(
-                new BooleanQuery.Builder().add(new SpanTermQuery(new Term("field", "foo")), occur)
-                    .add(new OpenSearchToParentBlockJoinQuery(new MatchAllDocsQuery(), producer, ScoreMode.Avg, "nested"), occur)
-                    .build(),
-                occur
-            ).build();
-            if (occur == Occur.MUST) {
-                assertTrue(hasInfMaxScore(query));
-            } else {
-                assertFalse(hasInfMaxScore(query));
-            }
-        }
-    }
-
-    // assert score docs are in order and their number is as expected
-    private void assertSortResults(TopDocs topDocs, long expectedNumDocs, boolean isDoubleSort) {
-        if (topDocs.totalHits.relation == TotalHits.Relation.GREATER_THAN_OR_EQUAL_TO) {
-            assertThat(topDocs.totalHits.value, lessThanOrEqualTo(expectedNumDocs));
-        } else {
-            assertEquals(topDocs.totalHits.value, expectedNumDocs);
-        }
-        long cur1, cur2;
-        long prev1 = Long.MIN_VALUE;
-        long prev2 = Long.MIN_VALUE;
-        for (ScoreDoc scoreDoc : topDocs.scoreDocs) {
-            cur1 = (long) ((FieldDoc) scoreDoc).fields[0];
-            assertThat(cur1, greaterThanOrEqualTo(prev1)); // test that docs are properly sorted on the first sort
-            if (isDoubleSort) {
-                cur2 = (long) ((FieldDoc) scoreDoc).fields[1];
-                if (cur1 == prev1) {
-                    assertThat(cur2, greaterThanOrEqualTo(prev2)); // test that docs are properly sorted on the secondary sort
-                }
-                prev2 = cur2;
-            }
-            prev1 = cur1;
-        }
-    }
-
-    public void testMinScore() throws Exception {
-        Directory dir = newDirectory();
-        IndexWriterConfig iwc = newIndexWriterConfig();
-        RandomIndexWriter w = new RandomIndexWriter(random(), dir, iwc);
-        for (int i = 0; i < 10; i++) {
-            Document doc = new Document();
-            doc.add(new StringField("foo", "bar", Store.NO));
-            doc.add(new StringField("filter", "f1", Store.NO));
-            w.addDocument(doc);
-        }
-        w.close();
-
-        IndexReader reader = DirectoryReader.open(dir);
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor));
-        context.parsedQuery(
-            new ParsedQuery(
-                new BooleanQuery.Builder().add(new TermQuery(new Term("foo", "bar")), Occur.MUST)
-                    .add(new TermQuery(new Term("filter", "f1")), Occur.SHOULD)
-                    .build()
-            )
-        );
-        context.minimumScore(0.01f);
-        context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-        context.setSize(1);
-        context.trackTotalHitsUpTo(5);
-
-        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-        assertEquals(10, context.queryResult().topDocs().topDocs.totalHits.value);
-
-        reader.close();
-        dir.close();
-    }
-
-    public void testMaxScore() throws Exception {
-        Directory dir = newDirectory();
-        final Sort sort = new Sort(new SortField("filter", SortField.Type.STRING));
-        IndexWriterConfig iwc = newIndexWriterConfig().setIndexSort(sort);
-        RandomIndexWriter w = new RandomIndexWriter(random(), dir, iwc);
-
-        final int numDocs = scaledRandomIntBetween(600, 900);
-        for (int i = 0; i < numDocs; i++) {
-            Document doc = new Document();
-            doc.add(new StringField("foo", "bar", Store.NO));
-            doc.add(new StringField("filter", "f1" + ((i > 0) ? " " + Integer.toString(i) : ""), Store.NO));
-            doc.add(new SortedDocValuesField("filter", newBytesRef("f1" + ((i > 0) ? " " + Integer.toString(i) : ""))));
-            w.addDocument(doc);
-        }
-        w.close();
-
-        IndexReader reader = DirectoryReader.open(dir);
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor));
-        context.trackScores(true);
-        context.parsedQuery(
-            new ParsedQuery(
-                new BooleanQuery.Builder().add(new TermQuery(new Term("foo", "bar")), Occur.MUST)
-                    .add(new TermQuery(new Term("filter", "f1")), Occur.SHOULD)
-                    .build()
-            )
-        );
-        context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-        context.setSize(1);
-        context.trackTotalHitsUpTo(5);
-
-        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-        assertFalse(Float.isNaN(context.queryResult().getMaxScore()));
-        assertEquals(1, context.queryResult().topDocs().topDocs.scoreDocs.length);
-        assertThat(context.queryResult().topDocs().topDocs.totalHits.value, greaterThanOrEqualTo(6L));
-
-        context.sort(new SortAndFormats(sort, new DocValueFormat[] { DocValueFormat.RAW }));
-        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-        assertFalse(Float.isNaN(context.queryResult().getMaxScore()));
-        assertEquals(1, context.queryResult().topDocs().topDocs.scoreDocs.length);
-        assertThat(context.queryResult().topDocs().topDocs.totalHits.value, greaterThanOrEqualTo(6L));
-
-        context.trackScores(false);
-        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-        assertTrue(Float.isNaN(context.queryResult().getMaxScore()));
-        assertEquals(1, context.queryResult().topDocs().topDocs.scoreDocs.length);
-        assertThat(context.queryResult().topDocs().topDocs.totalHits.value, greaterThanOrEqualTo(6L));
-
-        reader.close();
-        dir.close();
-    }
-
-    public void testCollapseQuerySearchResults() throws Exception {
-        Directory dir = newDirectory();
-        final Sort sort = new Sort(new SortField("user", SortField.Type.INT));
-        IndexWriterConfig iwc = newIndexWriterConfig().setIndexSort(sort);
-        RandomIndexWriter w = new RandomIndexWriter(random(), dir, iwc);
-
-        // Always end up with uneven buckets so collapsing is predictable
-        final int numDocs = 2 * scaledRandomIntBetween(600, 900) - 1;
-        for (int i = 0; i < numDocs; i++) {
-            Document doc = new Document();
-            doc.add(new StringField("foo", "bar", Store.NO));
-            doc.add(new NumericDocValuesField("user", i & 1));
-            w.addDocument(doc);
-        }
-        w.close();
-
-        IndexReader reader = DirectoryReader.open(dir);
-        QueryShardContext queryShardContext = mock(QueryShardContext.class);
-        when(queryShardContext.fieldMapper("user")).thenReturn(
-            new NumberFieldType("user", NumberType.INTEGER, true, false, true, false, null, Collections.emptyMap())
-        );
-
-        TestSearchContext context = new TestSearchContext(queryShardContext, indexShard, newContextSearcher(reader, executor));
-        context.collapse(new CollapseBuilder("user").build(context.getQueryShardContext()));
-        context.trackScores(true);
-        context.parsedQuery(new ParsedQuery(new TermQuery(new Term("foo", "bar"))));
-        context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-        context.setSize(2);
-        context.trackTotalHitsUpTo(5);
-
-        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-        assertFalse(Float.isNaN(context.queryResult().getMaxScore()));
-        assertEquals(2, context.queryResult().topDocs().topDocs.scoreDocs.length);
-        assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
-        assertThat(context.queryResult().topDocs().topDocs, instanceOf(CollapseTopFieldDocs.class));
-
-        CollapseTopFieldDocs topDocs = (CollapseTopFieldDocs) context.queryResult().topDocs().topDocs;
-        assertThat(topDocs.collapseValues.length, equalTo(2));
-        assertThat(topDocs.collapseValues[0], equalTo(0L)); // user == 0
-        assertThat(topDocs.collapseValues[1], equalTo(1L)); // user == 1
-
-        context.sort(new SortAndFormats(sort, new DocValueFormat[] { DocValueFormat.RAW }));
-        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-        assertFalse(Float.isNaN(context.queryResult().getMaxScore()));
-        assertEquals(2, context.queryResult().topDocs().topDocs.scoreDocs.length);
-        assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
-        assertThat(context.queryResult().topDocs().topDocs, instanceOf(CollapseTopFieldDocs.class));
-
-        topDocs = (CollapseTopFieldDocs) context.queryResult().topDocs().topDocs;
-        assertThat(topDocs.collapseValues.length, equalTo(2));
-        assertThat(topDocs.collapseValues[0], equalTo(0L)); // user == 0
-        assertThat(topDocs.collapseValues[1], equalTo(1L)); // user == 1
-
-        context.trackScores(false);
-        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
-        assertTrue(Float.isNaN(context.queryResult().getMaxScore()));
-        assertEquals(2, context.queryResult().topDocs().topDocs.scoreDocs.length);
-        assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
-        assertThat(context.queryResult().topDocs().topDocs, instanceOf(CollapseTopFieldDocs.class));
-
-        topDocs = (CollapseTopFieldDocs) context.queryResult().topDocs().topDocs;
-        assertThat(topDocs.collapseValues.length, equalTo(2));
-        assertThat(topDocs.collapseValues[0], equalTo(0L)); // user == 0
-        assertThat(topDocs.collapseValues[1], equalTo(1L)); // user == 1
-
-        reader.close();
-        dir.close();
-    }
-
-    public void testCancellationDuringPreprocess() throws IOException {
-        try (Directory dir = newDirectory(); RandomIndexWriter w = new RandomIndexWriter(random(), dir, newIndexWriterConfig())) {
-
-            for (int i = 0; i < 10; i++) {
-                Document doc = new Document();
-                StringBuilder sb = new StringBuilder();
-                for (int j = 0; j < i; j++) {
-                    sb.append('a');
-                }
-                doc.add(new StringField("foo", sb.toString(), Store.NO));
-                w.addDocument(doc);
-            }
-            w.flush();
-            w.close();
-
-            try (IndexReader reader = DirectoryReader.open(dir)) {
-                TestSearchContext context = new TestSearchContextWithRewriteAndCancellation(
-                    null,
-                    indexShard,
-                    newContextSearcher(reader, executor)
-                );
-                PrefixQuery prefixQuery = new PrefixQuery(new Term("foo", "a"), MultiTermQuery.SCORING_BOOLEAN_REWRITE);
-                context.parsedQuery(new ParsedQuery(prefixQuery));
-                SearchShardTask task = mock(SearchShardTask.class);
-                when(task.isCancelled()).thenReturn(true);
-                context.setTask(task);
-                expectThrows(TaskCancelledException.class, () -> new QueryPhase().preProcess(context));
-            }
-        }
-    }
-
-    private static class TestSearchContextWithRewriteAndCancellation extends TestSearchContext {
-
-        private TestSearchContextWithRewriteAndCancellation(
-            QueryShardContext queryShardContext,
-            IndexShard indexShard,
-            ContextIndexSearcher searcher
-        ) {
-            super(queryShardContext, indexShard, searcher);
-        }
-
-        @Override
-        public void preProcess(boolean rewrite) {
-            try {
-                searcher().rewrite(query());
-            } catch (IOException e) {
-                fail("IOException shouldn't be thrown");
-            }
-        }
-
-        @Override
-        public boolean lowLevelCancellation() {
-            return true;
-        }
-    }
-
-    private static ContextIndexSearcher newContextSearcher(IndexReader reader, ExecutorService executor) throws IOException {
-        return new ContextIndexSearcher(
-            reader,
-            IndexSearcher.getDefaultSimilarity(),
-            IndexSearcher.getDefaultQueryCache(),
-            IndexSearcher.getDefaultQueryCachingPolicy(),
-            true,
-            executor
-        );
-    }
-
-    private static ContextIndexSearcher newEarlyTerminationContextSearcher(IndexReader reader, int size, ExecutorService executor)
-        throws IOException {
-        return new ContextIndexSearcher(
-            reader,
-            IndexSearcher.getDefaultSimilarity(),
-            IndexSearcher.getDefaultQueryCache(),
-            IndexSearcher.getDefaultQueryCachingPolicy(),
-            true,
-            executor
-        ) {
-
-            @Override
-            public void search(List<LeafReaderContext> leaves, Weight weight, Collector collector) throws IOException {
-                final Collector in = new AssertingEarlyTerminationFilterCollector(collector, size);
-                super.search(leaves, weight, in);
-            }
-        };
-    }
-
-    private static class TestTotalHitCountCollectorManager extends TotalHitCountCollectorManager {
-        private int totalHits;
-        private final TotalHitCountCollector collector;
-        private final Integer teminateAfter;
-
-        static TestTotalHitCountCollectorManager create(final ExecutorService executor) {
-            return create(executor, null, null);
-        }
-
-        static TestTotalHitCountCollectorManager create(final ExecutorService executor, final Integer teminateAfter) {
-            return create(executor, null, teminateAfter);
-        }
-
-        static TestTotalHitCountCollectorManager create(final ExecutorService executor, final Sort sort) {
-            return create(executor, sort, null);
-        }
-
-        static TestTotalHitCountCollectorManager create(final ExecutorService executor, final Sort sort, final Integer teminateAfter) {
-            if (executor == null) {
-                return new TestTotalHitCountCollectorManager(new TotalHitCountCollector(), sort);
-            } else {
-                return new TestTotalHitCountCollectorManager(sort, teminateAfter);
-            }
-        }
-
-        private TestTotalHitCountCollectorManager(final TotalHitCountCollector collector, final Sort sort) {
-            super(sort);
-            this.collector = collector;
-            this.teminateAfter = null;
-        }
-
-        private TestTotalHitCountCollectorManager(final Sort sort, final Integer teminateAfter) {
-            super(sort);
-            this.collector = null;
-            this.teminateAfter = teminateAfter;
-        }
-
-        @Override
-        public TotalHitCountCollector newCollector() throws IOException {
-            return (collector == null) ? super.newCollector() : collector;
-        }
-
-        @Override
-        public ReduceableSearchResult reduce(Collection<TotalHitCountCollector> collectors) throws IOException {
-            final ReduceableSearchResult result = super.reduce(collectors);
-            totalHits = collectors.stream().mapToInt(TotalHitCountCollector::getTotalHits).sum();
-
-            if (teminateAfter != null) {
-                assertThat(totalHits, greaterThanOrEqualTo(teminateAfter));
-                totalHits = Math.min(totalHits, teminateAfter);
-            }
-
-            return result;
-        }
-
-        public int getTotalHits() {
-            return (collector == null) ? totalHits : collector.getTotalHits();
-        }
-    }
-
-    private static class AssertingEarlyTerminationFilterCollector extends FilterCollector {
-        private final int size;
-
-        AssertingEarlyTerminationFilterCollector(Collector in, int size) {
-            super(in);
-            this.size = size;
-        }
-
-        @Override
-        public LeafCollector getLeafCollector(LeafReaderContext context) throws IOException {
-            final LeafCollector in = super.getLeafCollector(context);
-            return new FilterLeafCollector(in) {
-                int collected;
-
-                @Override
-                public void collect(int doc) throws IOException {
-                    assert collected <= size : "should not collect more than " + size + " doc per segment, got " + collected;
-                    ++collected;
-                    super.collect(doc);
-                }
-            };
-        }
-    }
-}
diff --git a/sandbox/plugins/concurrent-search/src/test/java/org/opensearch/search/query/QueryProfilePhaseTests.java b/sandbox/plugins/concurrent-search/src/test/java/org/opensearch/search/query/QueryProfilePhaseTests.java
deleted file mode 100644
index ed10fe5cd84ca..0000000000000
--- a/sandbox/plugins/concurrent-search/src/test/java/org/opensearch/search/query/QueryProfilePhaseTests.java
+++ /dev/null
@@ -1,1213 +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.query;
-
-import com.carrotsearch.randomizedtesting.annotations.ParametersFactory;
-
-import org.apache.lucene.analysis.standard.StandardAnalyzer;
-import org.apache.lucene.document.Document;
-import org.apache.lucene.document.Field.Store;
-import org.apache.lucene.document.NumericDocValuesField;
-import org.apache.lucene.document.SortedDocValuesField;
-import org.apache.lucene.document.StringField;
-import org.apache.lucene.document.TextField;
-import org.apache.lucene.index.DirectoryReader;
-import org.apache.lucene.index.IndexReader;
-import org.apache.lucene.index.IndexWriterConfig;
-import org.apache.lucene.index.LeafReaderContext;
-import org.apache.lucene.index.Term;
-import org.apache.lucene.queries.spans.SpanNearQuery;
-import org.apache.lucene.queries.spans.SpanTermQuery;
-import org.apache.lucene.search.BooleanClause.Occur;
-import org.apache.lucene.search.grouping.CollapseTopFieldDocs;
-import org.apache.lucene.search.BooleanQuery;
-import org.apache.lucene.search.Collector;
-import org.apache.lucene.search.FieldComparator;
-import org.apache.lucene.search.FieldDoc;
-import org.apache.lucene.search.FilterCollector;
-import org.apache.lucene.search.FilterLeafCollector;
-import org.apache.lucene.search.IndexSearcher;
-import org.apache.lucene.search.LeafCollector;
-import org.apache.lucene.search.MatchAllDocsQuery;
-import org.apache.lucene.search.MatchNoDocsQuery;
-import org.apache.lucene.search.Query;
-import org.apache.lucene.search.Sort;
-import org.apache.lucene.search.SortField;
-import org.apache.lucene.search.TermQuery;
-import org.apache.lucene.search.TotalHits;
-import org.apache.lucene.search.Weight;
-import org.apache.lucene.tests.index.RandomIndexWriter;
-import org.apache.lucene.store.Directory;
-import org.opensearch.action.search.SearchShardTask;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.core.xcontent.ToXContent;
-import org.opensearch.core.xcontent.XContentBuilder;
-import org.opensearch.common.xcontent.json.JsonXContent;
-import org.opensearch.index.mapper.NumberFieldMapper.NumberFieldType;
-import org.opensearch.index.mapper.NumberFieldMapper.NumberType;
-import org.opensearch.index.query.ParsedQuery;
-import org.opensearch.index.query.QueryShardContext;
-import org.opensearch.index.shard.IndexShard;
-import org.opensearch.index.shard.IndexShardTestCase;
-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.profile.ProfileResult;
-import org.opensearch.search.profile.ProfileShardResult;
-import org.opensearch.search.profile.SearchProfileShardResults;
-import org.opensearch.search.profile.query.CollectorResult;
-import org.opensearch.search.profile.query.QueryProfileShardResult;
-import org.opensearch.search.sort.SortAndFormats;
-import org.opensearch.test.TestSearchContext;
-import org.opensearch.threadpool.ThreadPool;
-
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.OutputStream;
-import java.nio.charset.StandardCharsets;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.TimeUnit;
-import java.util.function.Consumer;
-
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.CoreMatchers.nullValue;
-import static org.hamcrest.Matchers.anyOf;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.empty;
-import static org.hamcrest.Matchers.greaterThan;
-import static org.hamcrest.Matchers.greaterThanOrEqualTo;
-import static org.hamcrest.Matchers.instanceOf;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-import static org.hamcrest.Matchers.hasSize;
-
-public class QueryProfilePhaseTests extends IndexShardTestCase {
-
-    private IndexShard indexShard;
-    private final ExecutorService executor;
-    private final QueryPhaseSearcher queryPhaseSearcher;
-
-    @ParametersFactory
-    public static Collection<Object[]> concurrency() {
-        return Arrays.asList(
-            new Object[] { 0, QueryPhase.DEFAULT_QUERY_PHASE_SEARCHER },
-            new Object[] { 5, new ConcurrentQueryPhaseSearcher() }
-        );
-    }
-
-    public QueryProfilePhaseTests(int concurrency, QueryPhaseSearcher queryPhaseSearcher) {
-        this.executor = (concurrency > 0) ? Executors.newFixedThreadPool(concurrency) : null;
-        this.queryPhaseSearcher = queryPhaseSearcher;
-    }
-
-    @Override
-    public Settings threadPoolSettings() {
-        return Settings.builder().put(super.threadPoolSettings()).put("thread_pool.search.min_queue_size", 10).build();
-    }
-
-    @Override
-    public void setUp() throws Exception {
-        super.setUp();
-        indexShard = newShard(true);
-    }
-
-    @Override
-    public void tearDown() throws Exception {
-        super.tearDown();
-        closeShards(indexShard);
-
-        if (executor != null) {
-            ThreadPool.terminate(executor, 10, TimeUnit.SECONDS);
-        }
-    }
-
-    public void testPostFilterDisablesCountOptimization() throws Exception {
-        Directory dir = newDirectory();
-        final Sort sort = new Sort(new SortField("rank", SortField.Type.INT));
-        IndexWriterConfig iwc = newIndexWriterConfig().setIndexSort(sort);
-        RandomIndexWriter w = new RandomIndexWriter(random(), dir, iwc);
-        Document doc = new Document();
-        w.addDocument(doc);
-        w.close();
-
-        IndexReader reader = DirectoryReader.open(dir);
-
-        TestSearchContext context = new TestSearchContext(null, indexShard, newEarlyTerminationContextSearcher(reader, 0, executor));
-        context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-        context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
-
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
-        assertEquals(1, context.queryResult().topDocs().topDocs.totalHits.value);
-        // IndexSearcher#rewrite optimizes by rewriting non-scoring queries to ConstantScoreQuery
-        // see: https://github.com/apache/lucene/pull/672
-        assertProfileData(context, "ConstantScoreQuery", query -> {
-            assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-            assertThat(query.getTimeBreakdown().get("score"), equalTo(0L));
-            assertThat(query.getTimeBreakdown().get("score_count"), equalTo(0L));
-            assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-            assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-        }, collector -> {
-            assertThat(collector.getReason(), equalTo("search_count"));
-            assertThat(collector.getTime(), greaterThan(0L));
-            assertThat(collector.getProfiledChildren(), empty());
-        });
-
-        context.setSearcher(newContextSearcher(reader, executor));
-        context.parsedPostFilter(new ParsedQuery(new MatchNoDocsQuery()));
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
-        assertEquals(0, context.queryResult().topDocs().topDocs.totalHits.value);
-        assertProfileData(context, collector -> {
-            assertThat(collector.getReason(), equalTo("search_post_filter"));
-            assertThat(collector.getTime(), greaterThan(0L));
-            assertThat(collector.getProfiledChildren(), hasSize(1));
-            assertThat(collector.getProfiledChildren().get(0).getReason(), equalTo("search_count"));
-            assertThat(collector.getProfiledChildren().get(0).getTime(), greaterThan(0L));
-        }, (query) -> {
-            assertThat(query.getQueryName(), equalTo("MatchNoDocsQuery"));
-            assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-            assertThat(query.getTimeBreakdown().get("score"), equalTo(0L));
-            assertThat(query.getTimeBreakdown().get("score_count"), equalTo(0L));
-            assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-            assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-        }, (query) -> {
-            // IndexSearcher#rewrite optimizes by rewriting non-scoring queries to ConstantScoreQuery
-            // see: https://github.com/apache/lucene/pull/672
-            assertThat(query.getQueryName(), equalTo("ConstantScoreQuery"));
-            assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-            assertThat(query.getTimeBreakdown().get("score"), equalTo(0L));
-            assertThat(query.getTimeBreakdown().get("score_count"), equalTo(0L));
-            assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-            assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-        });
-
-        reader.close();
-        dir.close();
-    }
-
-    public void testTerminateAfterWithFilter() throws Exception {
-        Directory dir = newDirectory();
-        final Sort sort = new Sort(new SortField("rank", SortField.Type.INT));
-        IndexWriterConfig iwc = newIndexWriterConfig().setIndexSort(sort);
-        RandomIndexWriter w = new RandomIndexWriter(random(), dir, iwc);
-        Document doc = new Document();
-        for (int i = 0; i < 10; i++) {
-            doc.add(new StringField("foo", Integer.toString(i), Store.NO));
-        }
-        w.addDocument(doc);
-        w.close();
-
-        IndexReader reader = DirectoryReader.open(dir);
-
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor));
-        context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-
-        context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
-        context.terminateAfter(1);
-        context.setSize(10);
-        for (int i = 0; i < 10; i++) {
-            context.parsedPostFilter(new ParsedQuery(new TermQuery(new Term("foo", Integer.toString(i)))));
-            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
-            assertEquals(1, context.queryResult().topDocs().topDocs.totalHits.value);
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
-            assertProfileData(context, collector -> {
-                assertThat(collector.getReason(), equalTo("search_post_filter"));
-                assertThat(collector.getTime(), greaterThan(0L));
-                assertThat(collector.getProfiledChildren(), hasSize(1));
-                assertThat(collector.getProfiledChildren().get(0).getReason(), equalTo("search_terminate_after_count"));
-                assertThat(collector.getProfiledChildren().get(0).getTime(), greaterThan(0L));
-                assertThat(collector.getProfiledChildren().get(0).getProfiledChildren(), hasSize(1));
-                assertThat(collector.getProfiledChildren().get(0).getProfiledChildren().get(0).getReason(), equalTo("search_top_hits"));
-                assertThat(collector.getProfiledChildren().get(0).getProfiledChildren().get(0).getTime(), greaterThan(0L));
-            }, (query) -> {
-                assertThat(query.getQueryName(), equalTo("TermQuery"));
-                assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-                assertThat(query.getTimeBreakdown().get("score"), equalTo(0L));
-                assertThat(query.getTimeBreakdown().get("score_count"), equalTo(0L));
-                assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-                assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-            }, (query) -> {
-                assertThat(query.getQueryName(), equalTo("MatchAllDocsQuery"));
-                assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-                assertThat(query.getTimeBreakdown().get("score"), greaterThan(0L));
-                assertThat(query.getTimeBreakdown().get("score_count"), equalTo(1L));
-                assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-                assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-            });
-        }
-        reader.close();
-        dir.close();
-    }
-
-    public void testMinScoreDisablesCountOptimization() throws Exception {
-        Directory dir = newDirectory();
-        final Sort sort = new Sort(new SortField("rank", SortField.Type.INT));
-        IndexWriterConfig iwc = newIndexWriterConfig().setIndexSort(sort);
-        RandomIndexWriter w = new RandomIndexWriter(random(), dir, iwc);
-        Document doc = new Document();
-        w.addDocument(doc);
-        w.close();
-
-        IndexReader reader = DirectoryReader.open(dir);
-        TestSearchContext context = new TestSearchContext(null, indexShard, newEarlyTerminationContextSearcher(reader, 0, executor));
-        context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
-        context.setSize(0);
-        context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
-        assertEquals(1, context.queryResult().topDocs().topDocs.totalHits.value);
-        // IndexSearcher#rewrite optimizes by rewriting non-scoring queries to ConstantScoreQuery
-        // see: https://github.com/apache/lucene/pull/672
-        assertProfileData(context, "ConstantScoreQuery", query -> {
-            assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-            assertThat(query.getTimeBreakdown().get("score"), equalTo(0L));
-            assertThat(query.getTimeBreakdown().get("score_count"), equalTo(0L));
-            assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-            assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-        }, collector -> {
-            assertThat(collector.getReason(), equalTo("search_count"));
-            assertThat(collector.getTime(), greaterThan(0L));
-            assertThat(collector.getProfiledChildren(), empty());
-        });
-
-        context.minimumScore(100);
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
-        assertEquals(0, context.queryResult().topDocs().topDocs.totalHits.value);
-        assertEquals(TotalHits.Relation.EQUAL_TO, context.queryResult().topDocs().topDocs.totalHits.relation);
-        assertProfileData(context, "MatchAllDocsQuery", query -> {
-            assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-            assertThat(query.getTimeBreakdown().get("score"), greaterThanOrEqualTo(100L));
-            assertThat(query.getTimeBreakdown().get("score_count"), equalTo(1L));
-            assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-            assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-        }, collector -> {
-            assertThat(collector.getReason(), equalTo("search_min_score"));
-            assertThat(collector.getTime(), greaterThan(0L));
-            assertThat(collector.getProfiledChildren(), hasSize(1));
-            assertThat(collector.getProfiledChildren().get(0).getReason(), equalTo("search_count"));
-            assertThat(collector.getProfiledChildren().get(0).getTime(), greaterThan(0L));
-        });
-
-        reader.close();
-        dir.close();
-    }
-
-    public void testInOrderScrollOptimization() throws Exception {
-        Directory dir = newDirectory();
-        final Sort sort = new Sort(new SortField("rank", SortField.Type.INT));
-        IndexWriterConfig iwc = newIndexWriterConfig().setIndexSort(sort);
-        RandomIndexWriter w = new RandomIndexWriter(random(), dir, iwc);
-        final int numDocs = scaledRandomIntBetween(600, 900);
-        for (int i = 0; i < numDocs; ++i) {
-            w.addDocument(new Document());
-        }
-        w.close();
-        IndexReader reader = DirectoryReader.open(dir);
-        ScrollContext scrollContext = new ScrollContext();
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor), scrollContext);
-        context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
-        context.sort(new SortAndFormats(sort, new DocValueFormat[] { DocValueFormat.RAW }));
-        scrollContext.lastEmittedDoc = null;
-        scrollContext.maxScore = Float.NaN;
-        scrollContext.totalHits = null;
-        context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-        int size = randomIntBetween(2, 5);
-        context.setSize(size);
-
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
-        assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
-        assertNull(context.queryResult().terminatedEarly());
-        assertThat(context.terminateAfter(), equalTo(0));
-        assertThat(context.queryResult().getTotalHits().value, equalTo((long) numDocs));
-        assertProfileData(context, "ConstantScoreQuery", query -> {
-            assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-            assertThat(query.getTimeBreakdown().get("score"), equalTo(0L));
-            assertThat(query.getTimeBreakdown().get("score_count"), equalTo(0L));
-            assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-            assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-        }, collector -> {
-            assertThat(collector.getReason(), equalTo("search_top_hits"));
-            assertThat(collector.getTime(), greaterThan(0L));
-            assertThat(collector.getProfiledChildren(), empty());
-        });
-
-        context.setSearcher(newEarlyTerminationContextSearcher(reader, size, executor));
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
-        assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
-        assertThat(context.queryResult().getTotalHits().value, equalTo((long) numDocs));
-        assertThat(context.queryResult().topDocs().topDocs.scoreDocs[0].doc, greaterThanOrEqualTo(size));
-        assertProfileData(context, "ConstantScoreQuery", query -> {
-            assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-            assertThat(query.getTimeBreakdown().get("score"), equalTo(0L));
-            assertThat(query.getTimeBreakdown().get("score_count"), equalTo(0L));
-            assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-            assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-            assertThat(query.getProfiledChildren().get(0).getTimeBreakdown().get("score"), equalTo(0L));
-            assertThat(query.getProfiledChildren().get(0).getTimeBreakdown().get("score_count"), equalTo(0L));
-            assertThat(query.getProfiledChildren().get(0).getTimeBreakdown().get("create_weight"), greaterThan(0L));
-            assertThat(query.getProfiledChildren().get(0).getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-        }, collector -> {
-            assertThat(collector.getReason(), equalTo("search_top_hits"));
-            assertThat(collector.getTime(), greaterThan(0L));
-            assertThat(collector.getProfiledChildren(), hasSize(0));
-        });
-
-        reader.close();
-        dir.close();
-    }
-
-    public void testTerminateAfterEarlyTermination() throws Exception {
-        Directory dir = newDirectory();
-        IndexWriterConfig iwc = newIndexWriterConfig();
-        RandomIndexWriter w = new RandomIndexWriter(random(), dir, iwc);
-        final int numDocs = scaledRandomIntBetween(600, 900);
-        for (int i = 0; i < numDocs; ++i) {
-            Document doc = new Document();
-            if (randomBoolean()) {
-                doc.add(new StringField("foo", "bar", Store.NO));
-            }
-            if (randomBoolean()) {
-                doc.add(new StringField("foo", "baz", Store.NO));
-            }
-            doc.add(new NumericDocValuesField("rank", numDocs - i));
-            w.addDocument(doc);
-        }
-        w.close();
-        final IndexReader reader = DirectoryReader.open(dir);
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor));
-        context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-        context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
-
-        context.terminateAfter(1);
-        {
-            context.setSize(1);
-            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
-            assertTrue(context.queryResult().terminatedEarly());
-            assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(1L));
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
-            assertProfileData(context, "MatchAllDocsQuery", query -> {
-                assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-                assertThat(query.getTimeBreakdown().get("score"), greaterThan(0L));
-                assertThat(query.getTimeBreakdown().get("score_count"), greaterThan(0L));
-                assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-                assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-            }, collector -> {
-                assertThat(collector.getReason(), equalTo("search_terminate_after_count"));
-                assertThat(collector.getTime(), greaterThan(0L));
-                assertThat(collector.getProfiledChildren(), hasSize(1));
-                assertThat(collector.getProfiledChildren().get(0).getReason(), equalTo("search_top_hits"));
-                assertThat(collector.getProfiledChildren().get(0).getTime(), greaterThan(0L));
-            });
-
-            context.setSize(0);
-            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
-            assertTrue(context.queryResult().terminatedEarly());
-            assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(1L));
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(0));
-            // IndexSearcher#rewrite optimizes by rewriting non-scoring queries to ConstantScoreQuery
-            // see: https://github.com/apache/lucene/pull/672
-            assertProfileData(context, "ConstantScoreQuery", query -> {
-                assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-                assertThat(query.getTimeBreakdown().get("score"), equalTo(0L));
-                assertThat(query.getTimeBreakdown().get("score_count"), equalTo(0L));
-                assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-                assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-            }, collector -> {
-                assertThat(collector.getReason(), equalTo("search_terminate_after_count"));
-                assertThat(collector.getTime(), greaterThan(0L));
-                assertThat(collector.getProfiledChildren(), hasSize(1));
-                assertThat(collector.getProfiledChildren().get(0).getReason(), equalTo("search_count"));
-                assertThat(collector.getProfiledChildren().get(0).getTime(), greaterThan(0L));
-            });
-        }
-
-        {
-            context.setSize(1);
-            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
-            assertTrue(context.queryResult().terminatedEarly());
-            assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(1L));
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
-            assertProfileData(context, "MatchAllDocsQuery", query -> {
-                assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-                assertThat(query.getTimeBreakdown().get("score"), greaterThan(0L));
-                assertThat(query.getTimeBreakdown().get("score_count"), greaterThan(0L));
-                assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-                assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-            }, collector -> {
-                assertThat(collector.getReason(), equalTo("search_terminate_after_count"));
-                assertThat(collector.getTime(), greaterThan(0L));
-                assertThat(collector.getProfiledChildren(), hasSize(1));
-                assertThat(collector.getProfiledChildren().get(0).getReason(), equalTo("search_top_hits"));
-                assertThat(collector.getProfiledChildren().get(0).getTime(), greaterThan(0L));
-            });
-        }
-        {
-            context.setSize(1);
-            BooleanQuery bq = new BooleanQuery.Builder().add(new TermQuery(new Term("foo", "bar")), Occur.SHOULD)
-                .add(new TermQuery(new Term("foo", "baz")), Occur.SHOULD)
-                .build();
-            context.parsedQuery(new ParsedQuery(bq));
-            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
-            assertTrue(context.queryResult().terminatedEarly());
-            assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(1L));
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
-            assertProfileData(context, "BooleanQuery", query -> {
-                assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-                assertThat(query.getTimeBreakdown().get("score"), greaterThan(0L));
-                assertThat(query.getTimeBreakdown().get("score_count"), greaterThan(0L));
-                assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-                assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-
-                assertThat(query.getProfiledChildren(), hasSize(2));
-                assertThat(query.getProfiledChildren().get(0).getQueryName(), equalTo("TermQuery"));
-                assertThat(query.getProfiledChildren().get(0).getTime(), greaterThan(0L));
-                assertThat(query.getProfiledChildren().get(0).getTimeBreakdown().get("create_weight"), greaterThan(0L));
-                assertThat(query.getProfiledChildren().get(0).getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-
-                assertThat(query.getProfiledChildren().get(1).getQueryName(), equalTo("TermQuery"));
-                assertThat(query.getProfiledChildren().get(1).getTime(), greaterThan(0L));
-                assertThat(query.getProfiledChildren().get(1).getTimeBreakdown().get("create_weight"), greaterThan(0L));
-                assertThat(query.getProfiledChildren().get(1).getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-            }, collector -> {
-                assertThat(collector.getReason(), equalTo("search_terminate_after_count"));
-                assertThat(collector.getTime(), greaterThan(0L));
-                assertThat(collector.getProfiledChildren(), hasSize(1));
-                assertThat(collector.getProfiledChildren().get(0).getReason(), equalTo("search_top_hits"));
-                assertThat(collector.getProfiledChildren().get(0).getTime(), greaterThan(0L));
-            });
-            context.setSize(0);
-            context.parsedQuery(new ParsedQuery(bq));
-            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
-            assertTrue(context.queryResult().terminatedEarly());
-            assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(1L));
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(0));
-
-            // IndexSearcher#rewrite optimizes by rewriting non-scoring queries to ConstantScoreQuery
-            // see: https://github.com/apache/lucene/pull/672
-            assertProfileData(context, "ConstantScoreQuery", query -> {
-                assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-                assertThat(query.getTimeBreakdown().get("score"), equalTo(0L));
-                assertThat(query.getTimeBreakdown().get("score_count"), equalTo(0L));
-                assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-                assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-
-                // rewritten as a ConstantScoreQuery wrapping the original BooleanQuery
-                // see: https://github.com/apache/lucene/pull/672
-                assertThat(query.getProfiledChildren(), hasSize(1));
-                assertThat(query.getProfiledChildren().get(0).getQueryName(), equalTo("BooleanQuery"));
-                assertThat(query.getProfiledChildren().get(0).getTime(), greaterThan(0L));
-                assertThat(query.getProfiledChildren().get(0).getTimeBreakdown().get("create_weight"), greaterThan(0L));
-                assertThat(query.getProfiledChildren().get(0).getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-                assertThat(query.getProfiledChildren().get(0).getTimeBreakdown().get("score"), equalTo(0L));
-                assertThat(query.getProfiledChildren().get(0).getTimeBreakdown().get("score_count"), equalTo(0L));
-
-                List<ProfileResult> children = query.getProfiledChildren().get(0).getProfiledChildren();
-                assertThat(children, hasSize(2));
-                assertThat(children.get(0).getQueryName(), equalTo("TermQuery"));
-                assertThat(children.get(0).getTime(), greaterThan(0L));
-                assertThat(children.get(0).getTimeBreakdown().get("create_weight"), greaterThan(0L));
-                assertThat(children.get(0).getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-                assertThat(children.get(0).getTimeBreakdown().get("score"), equalTo(0L));
-                assertThat(children.get(0).getTimeBreakdown().get("score_count"), equalTo(0L));
-
-                assertThat(children.get(1).getQueryName(), equalTo("TermQuery"));
-                assertThat(children.get(1).getTime(), greaterThan(0L));
-                assertThat(children.get(1).getTimeBreakdown().get("create_weight"), greaterThan(0L));
-                assertThat(children.get(1).getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-                assertThat(children.get(1).getTimeBreakdown().get("score"), equalTo(0L));
-                assertThat(children.get(1).getTimeBreakdown().get("score_count"), equalTo(0L));
-            }, collector -> {
-                assertThat(collector.getReason(), equalTo("search_terminate_after_count"));
-                assertThat(collector.getTime(), greaterThan(0L));
-                assertThat(collector.getProfiledChildren(), hasSize(1));
-                assertThat(collector.getProfiledChildren().get(0).getReason(), equalTo("search_count"));
-                assertThat(collector.getProfiledChildren().get(0).getTime(), greaterThan(0L));
-            });
-        }
-
-        context.terminateAfter(7);
-        context.setSize(10);
-        for (int trackTotalHits : new int[] { -1, 3, 75, 100 }) {
-            context.trackTotalHitsUpTo(trackTotalHits);
-            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
-            assertTrue(context.queryResult().terminatedEarly());
-            if (trackTotalHits == -1) {
-                assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(0L));
-            } else {
-                assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(7L));
-            }
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(7));
-            assertProfileData(context, "BooleanQuery", query -> {
-                assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-                assertThat(query.getTimeBreakdown().get("score"), greaterThan(0L));
-                assertThat(query.getTimeBreakdown().get("score_count"), greaterThanOrEqualTo(7L));
-                assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-                assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-
-                assertThat(query.getProfiledChildren(), hasSize(2));
-                assertThat(query.getProfiledChildren().get(0).getQueryName(), equalTo("TermQuery"));
-                assertThat(query.getProfiledChildren().get(0).getTime(), greaterThan(0L));
-                assertThat(query.getProfiledChildren().get(0).getTimeBreakdown().get("create_weight"), greaterThan(0L));
-                assertThat(query.getProfiledChildren().get(0).getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-                assertThat(query.getProfiledChildren().get(0).getTimeBreakdown().get("score"), greaterThan(0L));
-                assertThat(query.getProfiledChildren().get(0).getTimeBreakdown().get("score_count"), greaterThan(0L));
-
-                assertThat(query.getProfiledChildren().get(1).getQueryName(), equalTo("TermQuery"));
-                assertThat(query.getProfiledChildren().get(1).getTime(), greaterThan(0L));
-                assertThat(query.getProfiledChildren().get(1).getTimeBreakdown().get("create_weight"), greaterThan(0L));
-                assertThat(query.getProfiledChildren().get(1).getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-                assertThat(query.getProfiledChildren().get(1).getTimeBreakdown().get("score"), greaterThan(0L));
-                assertThat(query.getProfiledChildren().get(1).getTimeBreakdown().get("score_count"), greaterThan(0L));
-            }, collector -> {
-                assertThat(collector.getReason(), equalTo("search_terminate_after_count"));
-                assertThat(collector.getTime(), greaterThan(0L));
-                assertThat(collector.getProfiledChildren(), hasSize(1));
-                assertThat(collector.getProfiledChildren().get(0).getReason(), equalTo("search_top_hits"));
-                assertThat(collector.getProfiledChildren().get(0).getTime(), greaterThan(0L));
-            });
-        }
-
-        reader.close();
-        dir.close();
-    }
-
-    public void testIndexSortingEarlyTermination() throws Exception {
-        Directory dir = newDirectory();
-        final Sort sort = new Sort(new SortField("rank", SortField.Type.INT));
-        IndexWriterConfig iwc = newIndexWriterConfig().setIndexSort(sort);
-        RandomIndexWriter w = new RandomIndexWriter(random(), dir, iwc);
-        final int numDocs = scaledRandomIntBetween(600, 900);
-        for (int i = 0; i < numDocs; ++i) {
-            Document doc = new Document();
-            if (randomBoolean()) {
-                doc.add(new StringField("foo", "bar", Store.NO));
-            }
-            if (randomBoolean()) {
-                doc.add(new StringField("foo", "baz", Store.NO));
-            }
-            doc.add(new NumericDocValuesField("rank", numDocs - i));
-            w.addDocument(doc);
-        }
-        w.close();
-
-        final IndexReader reader = DirectoryReader.open(dir);
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor));
-        context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
-        context.setSize(1);
-        context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-        context.sort(new SortAndFormats(sort, new DocValueFormat[] { DocValueFormat.RAW }));
-
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
-        assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
-        assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
-        assertThat(context.queryResult().topDocs().topDocs.scoreDocs[0], instanceOf(FieldDoc.class));
-        FieldDoc fieldDoc = (FieldDoc) context.queryResult().topDocs().topDocs.scoreDocs[0];
-        assertThat(fieldDoc.fields[0], equalTo(1));
-        // IndexSearcher#rewrite optimizes by rewriting non-scoring queries to ConstantScoreQuery
-        // see: https://github.com/apache/lucene/pull/672
-        assertProfileData(context, "ConstantScoreQuery", query -> {
-            assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-            assertThat(query.getTimeBreakdown().get("score"), equalTo(0L));
-            assertThat(query.getTimeBreakdown().get("score_count"), equalTo(0L));
-            assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-            assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-        }, collector -> {
-            assertThat(collector.getReason(), equalTo("search_top_hits"));
-            assertThat(collector.getTime(), greaterThan(0L));
-            assertThat(collector.getProfiledChildren(), empty());
-        });
-
-        {
-            context.parsedPostFilter(new ParsedQuery(new MinDocQuery(1)));
-            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
-            assertNull(context.queryResult().terminatedEarly());
-            assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(numDocs - 1L));
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs[0], instanceOf(FieldDoc.class));
-            assertThat(fieldDoc.fields[0], anyOf(equalTo(1), equalTo(2)));
-            assertProfileData(context, collector -> {
-                assertThat(collector.getReason(), equalTo("search_post_filter"));
-                assertThat(collector.getTime(), greaterThan(0L));
-                assertThat(collector.getProfiledChildren(), hasSize(1));
-                assertThat(collector.getProfiledChildren().get(0).getReason(), equalTo("search_top_hits"));
-                assertThat(collector.getProfiledChildren().get(0).getTime(), greaterThan(0L));
-            }, (query) -> {
-                assertThat(query.getQueryName(), equalTo("MinDocQuery"));
-                assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-                assertThat(query.getTimeBreakdown().get("score"), equalTo(0L));
-                assertThat(query.getTimeBreakdown().get("score_count"), equalTo(0L));
-                assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-                assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-            }, (query) -> {
-                // IndexSearcher#rewrite optimizes by rewriting non-scoring queries to ConstantScoreQuery
-                // see: https://github.com/apache/lucene/pull/672
-                assertThat(query.getQueryName(), equalTo("ConstantScoreQuery"));
-                assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-                assertThat(query.getTimeBreakdown().get("score"), equalTo(0L));
-                assertThat(query.getTimeBreakdown().get("score_count"), equalTo(0L));
-                assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-                assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-            });
-            context.parsedPostFilter(null);
-        }
-
-        {
-            context.setSearcher(newEarlyTerminationContextSearcher(reader, 1, executor));
-            context.trackTotalHitsUpTo(SearchContext.TRACK_TOTAL_HITS_DISABLED);
-            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
-            assertNull(context.queryResult().terminatedEarly());
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs[0], instanceOf(FieldDoc.class));
-            assertThat(fieldDoc.fields[0], anyOf(equalTo(1), equalTo(2)));
-            // IndexSearcher#rewrite optimizes by rewriting non-scoring queries to ConstantScoreQuery
-            // see: https://github.com/apache/lucene/pull/672
-            assertProfileData(context, "ConstantScoreQuery", query -> {
-                assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-                assertThat(query.getTimeBreakdown().get("score"), equalTo(0L));
-                assertThat(query.getTimeBreakdown().get("score_count"), equalTo(0L));
-                assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-                assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-            }, collector -> {
-                assertThat(collector.getReason(), equalTo("search_top_hits"));
-                assertThat(collector.getTime(), greaterThan(0L));
-                assertThat(collector.getProfiledChildren(), empty());
-            });
-
-            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
-            assertNull(context.queryResult().terminatedEarly());
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
-            assertThat(context.queryResult().topDocs().topDocs.scoreDocs[0], instanceOf(FieldDoc.class));
-            assertThat(fieldDoc.fields[0], anyOf(equalTo(1), equalTo(2)));
-            // IndexSearcher#rewrite optimizes by rewriting non-scoring queries to ConstantScoreQuery
-            // see: https://github.com/apache/lucene/pull/672
-            assertProfileData(context, "ConstantScoreQuery", query -> {
-                assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-                assertThat(query.getTimeBreakdown().get("score"), equalTo(0L));
-                assertThat(query.getTimeBreakdown().get("score_count"), equalTo(0L));
-                assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-                assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-            }, collector -> {
-                assertThat(collector.getReason(), equalTo("search_top_hits"));
-                assertThat(collector.getTime(), greaterThan(0L));
-                assertThat(collector.getProfiledChildren(), empty());
-            });
-        }
-
-        reader.close();
-        dir.close();
-    }
-
-    public void testIndexSortScrollOptimization() throws Exception {
-        Directory dir = newDirectory();
-        final Sort indexSort = new Sort(new SortField("rank", SortField.Type.INT), new SortField("tiebreaker", SortField.Type.INT));
-        IndexWriterConfig iwc = newIndexWriterConfig().setIndexSort(indexSort);
-        RandomIndexWriter w = new RandomIndexWriter(random(), dir, iwc);
-        final int numDocs = scaledRandomIntBetween(600, 900);
-        for (int i = 0; i < numDocs; ++i) {
-            Document doc = new Document();
-            doc.add(new NumericDocValuesField("rank", random().nextInt()));
-            doc.add(new NumericDocValuesField("tiebreaker", i));
-            w.addDocument(doc);
-        }
-        if (randomBoolean()) {
-            w.forceMerge(randomIntBetween(1, 10));
-        }
-        w.close();
-
-        final IndexReader reader = DirectoryReader.open(dir);
-        List<SortAndFormats> searchSortAndFormats = new ArrayList<>();
-        searchSortAndFormats.add(new SortAndFormats(indexSort, new DocValueFormat[] { DocValueFormat.RAW, DocValueFormat.RAW }));
-        // search sort is a prefix of the index sort
-        searchSortAndFormats.add(new SortAndFormats(new Sort(indexSort.getSort()[0]), new DocValueFormat[] { DocValueFormat.RAW }));
-        for (SortAndFormats searchSortAndFormat : searchSortAndFormats) {
-            ScrollContext scrollContext = new ScrollContext();
-            TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor), scrollContext);
-            context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
-            scrollContext.lastEmittedDoc = null;
-            scrollContext.maxScore = Float.NaN;
-            scrollContext.totalHits = null;
-            context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-            context.setSize(10);
-            context.sort(searchSortAndFormat);
-
-            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
-            assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
-            assertNull(context.queryResult().terminatedEarly());
-            assertThat(context.terminateAfter(), equalTo(0));
-            assertThat(context.queryResult().getTotalHits().value, equalTo((long) numDocs));
-            // IndexSearcher#rewrite optimizes by rewriting non-scoring queries to ConstantScoreQuery
-            // see: https://github.com/apache/lucene/pull/672
-            assertProfileData(context, "ConstantScoreQuery", query -> {
-                assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-                assertThat(query.getTimeBreakdown().get("score"), equalTo(0L));
-                assertThat(query.getTimeBreakdown().get("score_count"), equalTo(0L));
-                assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-                assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-            }, collector -> {
-                assertThat(collector.getReason(), equalTo("search_top_hits"));
-                assertThat(collector.getTime(), greaterThan(0L));
-                assertThat(collector.getProfiledChildren(), empty());
-            });
-
-            int sizeMinus1 = context.queryResult().topDocs().topDocs.scoreDocs.length - 1;
-            FieldDoc lastDoc = (FieldDoc) context.queryResult().topDocs().topDocs.scoreDocs[sizeMinus1];
-
-            context.setSearcher(newEarlyTerminationContextSearcher(reader, 10, executor));
-            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
-            assertNull(context.queryResult().terminatedEarly());
-            assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
-            assertThat(context.terminateAfter(), equalTo(0));
-            assertThat(context.queryResult().getTotalHits().value, equalTo((long) numDocs));
-            assertProfileData(context, "ConstantScoreQuery", query -> {
-                assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-                assertThat(query.getTimeBreakdown().get("score"), equalTo(0L));
-                assertThat(query.getTimeBreakdown().get("score_count"), equalTo(0L));
-                assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-                assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-
-                assertThat(query.getProfiledChildren(), hasSize(1));
-                assertThat(query.getProfiledChildren().get(0).getQueryName(), equalTo("SearchAfterSortedDocQuery"));
-                assertThat(query.getProfiledChildren().get(0).getTime(), greaterThan(0L));
-                assertThat(query.getProfiledChildren().get(0).getTimeBreakdown().get("score"), equalTo(0L));
-                assertThat(query.getProfiledChildren().get(0).getTimeBreakdown().get("score_count"), equalTo(0L));
-                assertThat(query.getProfiledChildren().get(0).getTimeBreakdown().get("create_weight"), greaterThan(0L));
-                assertThat(query.getProfiledChildren().get(0).getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-            }, collector -> {
-                assertThat(collector.getReason(), equalTo("search_top_hits"));
-                assertThat(collector.getTime(), greaterThan(0L));
-                assertThat(collector.getProfiledChildren(), empty());
-            });
-            FieldDoc firstDoc = (FieldDoc) context.queryResult().topDocs().topDocs.scoreDocs[0];
-            for (int i = 0; i < searchSortAndFormat.sort.getSort().length; i++) {
-                @SuppressWarnings("unchecked")
-                FieldComparator<Object> comparator = (FieldComparator<Object>) searchSortAndFormat.sort.getSort()[i].getComparator(i, true);
-                int cmp = comparator.compareValues(firstDoc.fields[i], lastDoc.fields[i]);
-                if (cmp == 0) {
-                    continue;
-                }
-                assertThat(cmp, equalTo(1));
-                break;
-            }
-        }
-        reader.close();
-        dir.close();
-    }
-
-    public void testDisableTopScoreCollection() throws Exception {
-        Directory dir = newDirectory();
-        IndexWriterConfig iwc = newIndexWriterConfig(new StandardAnalyzer());
-        RandomIndexWriter w = new RandomIndexWriter(random(), dir, iwc);
-        Document doc = new Document();
-        final int numDocs = 2 * scaledRandomIntBetween(50, 450);
-        for (int i = 0; i < numDocs; i++) {
-            doc.clear();
-            if (i % 2 == 0) {
-                doc.add(new TextField("title", "foo bar", Store.NO));
-            } else {
-                doc.add(new TextField("title", "foo", Store.NO));
-            }
-            w.addDocument(doc);
-        }
-        w.close();
-
-        IndexReader reader = DirectoryReader.open(dir);
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor));
-        context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-        Query q = new SpanNearQuery.Builder("title", true).addClause(new SpanTermQuery(new Term("title", "foo")))
-            .addClause(new SpanTermQuery(new Term("title", "bar")))
-            .build();
-
-        context.parsedQuery(new ParsedQuery(q));
-        context.setSize(3);
-        context.trackTotalHitsUpTo(3);
-        TopDocsCollectorContext topDocsContext = TopDocsCollectorContext.createTopDocsCollectorContext(context, false);
-        assertEquals(topDocsContext.create(null).scoreMode(), org.apache.lucene.search.ScoreMode.COMPLETE);
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
-        assertEquals(numDocs / 2, context.queryResult().topDocs().topDocs.totalHits.value);
-        assertEquals(context.queryResult().topDocs().topDocs.totalHits.relation, TotalHits.Relation.EQUAL_TO);
-        assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(3));
-        assertProfileData(context, "SpanNearQuery", query -> {
-            assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-            assertThat(query.getTimeBreakdown().get("score"), greaterThan(0L));
-            assertThat(query.getTimeBreakdown().get("score_count"), greaterThan(0L));
-            assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-            assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-        }, collector -> {
-            assertThat(collector.getReason(), equalTo("search_top_hits"));
-            assertThat(collector.getTime(), greaterThan(0L));
-            assertThat(collector.getProfiledChildren(), empty());
-        });
-
-        context.sort(new SortAndFormats(new Sort(new SortField("other", SortField.Type.INT)), new DocValueFormat[] { DocValueFormat.RAW }));
-        topDocsContext = TopDocsCollectorContext.createTopDocsCollectorContext(context, false);
-        assertEquals(topDocsContext.create(null).scoreMode(), org.apache.lucene.search.ScoreMode.TOP_DOCS);
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
-        assertEquals(numDocs / 2, context.queryResult().topDocs().topDocs.totalHits.value);
-        assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(3));
-        assertEquals(context.queryResult().topDocs().topDocs.totalHits.relation, TotalHits.Relation.GREATER_THAN_OR_EQUAL_TO);
-        // IndexSearcher#rewrite optimizes by rewriting non-scoring queries to ConstantScoreQuery
-        // see: https://github.com/apache/lucene/pull/672
-        assertProfileData(context, "ConstantScoreQuery", query -> {
-            assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-            assertThat(query.getTimeBreakdown().get("score"), equalTo(0L));
-            assertThat(query.getTimeBreakdown().get("score_count"), equalTo(0L));
-            assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-            assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-        }, collector -> {
-            assertThat(collector.getReason(), equalTo("search_top_hits"));
-            assertThat(collector.getTime(), greaterThan(0L));
-            assertThat(collector.getProfiledChildren(), empty());
-        });
-
-        reader.close();
-        dir.close();
-    }
-
-    public void testMinScore() throws Exception {
-        Directory dir = newDirectory();
-        IndexWriterConfig iwc = newIndexWriterConfig();
-        RandomIndexWriter w = new RandomIndexWriter(random(), dir, iwc);
-        for (int i = 0; i < 10; i++) {
-            Document doc = new Document();
-            doc.add(new StringField("foo", "bar", Store.NO));
-            doc.add(new StringField("filter", "f1", Store.NO));
-            w.addDocument(doc);
-        }
-        w.close();
-
-        IndexReader reader = DirectoryReader.open(dir);
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor));
-        context.parsedQuery(
-            new ParsedQuery(
-                new BooleanQuery.Builder().add(new TermQuery(new Term("foo", "bar")), Occur.MUST)
-                    .add(new TermQuery(new Term("filter", "f1")), Occur.SHOULD)
-                    .build()
-            )
-        );
-        context.minimumScore(0.01f);
-        context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-        context.setSize(1);
-        context.trackTotalHitsUpTo(5);
-
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
-        assertEquals(10, context.queryResult().topDocs().topDocs.totalHits.value);
-        assertProfileData(context, "BooleanQuery", query -> {
-            assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-            assertThat(query.getTimeBreakdown().get("score"), greaterThan(0L));
-            assertThat(query.getTimeBreakdown().get("score_count"), equalTo(10L));
-            assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-            assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-
-            assertThat(query.getProfiledChildren(), hasSize(2));
-            assertThat(query.getProfiledChildren().get(0).getQueryName(), equalTo("TermQuery"));
-            assertThat(query.getProfiledChildren().get(0).getTime(), greaterThan(0L));
-            assertThat(query.getProfiledChildren().get(0).getTimeBreakdown().get("create_weight"), greaterThan(0L));
-            assertThat(query.getProfiledChildren().get(0).getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-
-            assertThat(query.getProfiledChildren().get(1).getQueryName(), equalTo("TermQuery"));
-            assertThat(query.getProfiledChildren().get(1).getTime(), greaterThan(0L));
-            assertThat(query.getProfiledChildren().get(1).getTimeBreakdown().get("create_weight"), greaterThan(0L));
-            assertThat(query.getProfiledChildren().get(1).getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-        }, collector -> {
-            assertThat(collector.getReason(), equalTo("search_min_score"));
-            assertThat(collector.getTime(), greaterThan(0L));
-            assertThat(collector.getProfiledChildren(), hasSize(1));
-            assertThat(collector.getProfiledChildren().get(0).getReason(), equalTo("search_top_hits"));
-            assertThat(collector.getProfiledChildren().get(0).getTime(), greaterThan(0L));
-        });
-
-        reader.close();
-        dir.close();
-    }
-
-    public void testMaxScore() throws Exception {
-        Directory dir = newDirectory();
-        final Sort sort = new Sort(new SortField("filter", SortField.Type.STRING));
-        IndexWriterConfig iwc = newIndexWriterConfig().setIndexSort(sort);
-        RandomIndexWriter w = new RandomIndexWriter(random(), dir, iwc);
-
-        final int numDocs = scaledRandomIntBetween(600, 900);
-        for (int i = 0; i < numDocs; i++) {
-            Document doc = new Document();
-            doc.add(new StringField("foo", "bar", Store.NO));
-            doc.add(new StringField("filter", "f1" + ((i > 0) ? " " + Integer.toString(i) : ""), Store.NO));
-            doc.add(new SortedDocValuesField("filter", newBytesRef("f1" + ((i > 0) ? " " + Integer.toString(i) : ""))));
-            w.addDocument(doc);
-        }
-        w.close();
-
-        IndexReader reader = DirectoryReader.open(dir);
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor));
-        context.trackScores(true);
-        context.parsedQuery(
-            new ParsedQuery(
-                new BooleanQuery.Builder().add(new TermQuery(new Term("foo", "bar")), Occur.MUST)
-                    .add(new TermQuery(new Term("filter", "f1")), Occur.SHOULD)
-                    .build()
-            )
-        );
-        context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-        context.setSize(1);
-        context.trackTotalHitsUpTo(5);
-
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
-        assertFalse(Float.isNaN(context.queryResult().getMaxScore()));
-        assertEquals(1, context.queryResult().topDocs().topDocs.scoreDocs.length);
-        assertThat(context.queryResult().topDocs().topDocs.totalHits.value, greaterThanOrEqualTo(6L));
-        assertProfileData(context, "BooleanQuery", query -> {
-            assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-            assertThat(query.getTimeBreakdown().get("score"), greaterThan(0L));
-            assertThat(query.getTimeBreakdown().get("score_count"), greaterThanOrEqualTo(6L));
-            assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-            assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-
-            assertThat(query.getProfiledChildren(), hasSize(2));
-            assertThat(query.getProfiledChildren().get(0).getQueryName(), equalTo("TermQuery"));
-            assertThat(query.getProfiledChildren().get(0).getTime(), greaterThan(0L));
-            assertThat(query.getProfiledChildren().get(0).getTimeBreakdown().get("create_weight"), greaterThan(0L));
-            assertThat(query.getProfiledChildren().get(0).getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-
-            assertThat(query.getProfiledChildren().get(1).getQueryName(), equalTo("TermQuery"));
-            assertThat(query.getProfiledChildren().get(1).getTime(), greaterThan(0L));
-            assertThat(query.getProfiledChildren().get(1).getTimeBreakdown().get("create_weight"), greaterThan(0L));
-            assertThat(query.getProfiledChildren().get(1).getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-        }, collector -> {
-            assertThat(collector.getReason(), equalTo("search_top_hits"));
-            assertThat(collector.getTime(), greaterThan(0L));
-            assertThat(collector.getProfiledChildren(), empty());
-        });
-
-        context.sort(new SortAndFormats(sort, new DocValueFormat[] { DocValueFormat.RAW }));
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
-        assertFalse(Float.isNaN(context.queryResult().getMaxScore()));
-        assertEquals(1, context.queryResult().topDocs().topDocs.scoreDocs.length);
-        assertThat(context.queryResult().topDocs().topDocs.totalHits.value, greaterThanOrEqualTo(6L));
-        assertProfileData(context, "BooleanQuery", query -> {
-            assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-            assertThat(query.getTimeBreakdown().get("score"), greaterThan(0L));
-            assertThat(query.getTimeBreakdown().get("score_count"), greaterThanOrEqualTo(6L));
-            assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
-            assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-
-            assertThat(query.getProfiledChildren(), hasSize(2));
-            assertThat(query.getProfiledChildren().get(0).getQueryName(), equalTo("TermQuery"));
-            assertThat(query.getProfiledChildren().get(0).getTime(), greaterThan(0L));
-            assertThat(query.getProfiledChildren().get(0).getTimeBreakdown().get("create_weight"), greaterThan(0L));
-            assertThat(query.getProfiledChildren().get(0).getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-
-            assertThat(query.getProfiledChildren().get(1).getQueryName(), equalTo("TermQuery"));
-            assertThat(query.getProfiledChildren().get(1).getTime(), greaterThan(0L));
-            assertThat(query.getProfiledChildren().get(1).getTimeBreakdown().get("create_weight"), greaterThan(0L));
-            assertThat(query.getProfiledChildren().get(1).getTimeBreakdown().get("create_weight_count"), equalTo(1L));
-        }, collector -> {
-            assertThat(collector.getReason(), equalTo("search_top_hits"));
-            assertThat(collector.getTime(), greaterThan(0L));
-            assertThat(collector.getProfiledChildren(), empty());
-        });
-
-        reader.close();
-        dir.close();
-    }
-
-    public void testCollapseQuerySearchResults() throws Exception {
-        Directory dir = newDirectory();
-        final Sort sort = new Sort(new SortField("user", SortField.Type.INT));
-        IndexWriterConfig iwc = newIndexWriterConfig().setIndexSort(sort);
-        RandomIndexWriter w = new RandomIndexWriter(random(), dir, iwc);
-
-        // Always end up with uneven buckets so collapsing is predictable
-        final int numDocs = 2 * scaledRandomIntBetween(600, 900) - 1;
-        for (int i = 0; i < numDocs; i++) {
-            Document doc = new Document();
-            doc.add(new StringField("foo", "bar", Store.NO));
-            doc.add(new NumericDocValuesField("user", i & 1));
-            w.addDocument(doc);
-        }
-        w.close();
-
-        IndexReader reader = DirectoryReader.open(dir);
-        QueryShardContext queryShardContext = mock(QueryShardContext.class);
-        when(queryShardContext.fieldMapper("user")).thenReturn(
-            new NumberFieldType("user", NumberType.INTEGER, true, false, true, false, null, Collections.emptyMap())
-        );
-
-        TestSearchContext context = new TestSearchContext(queryShardContext, indexShard, newContextSearcher(reader, executor));
-        context.collapse(new CollapseBuilder("user").build(context.getQueryShardContext()));
-        context.trackScores(true);
-        context.parsedQuery(new ParsedQuery(new TermQuery(new Term("foo", "bar"))));
-        context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-        context.setSize(2);
-        context.trackTotalHitsUpTo(5);
-
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
-        assertFalse(Float.isNaN(context.queryResult().getMaxScore()));
-        assertEquals(2, context.queryResult().topDocs().topDocs.scoreDocs.length);
-        assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
-        assertThat(context.queryResult().topDocs().topDocs, instanceOf(CollapseTopFieldDocs.class));
-
-        assertProfileData(context, "TermQuery", query -> {
-            assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-            assertThat(query.getTimeBreakdown().get("score"), greaterThan(0L));
-            assertThat(query.getTimeBreakdown().get("score_count"), greaterThanOrEqualTo(6L));
-            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));
-            assertThat(collector.getProfiledChildren(), empty());
-        });
-
-        context.sort(new SortAndFormats(sort, new DocValueFormat[] { DocValueFormat.RAW }));
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
-        assertFalse(Float.isNaN(context.queryResult().getMaxScore()));
-        assertEquals(2, context.queryResult().topDocs().topDocs.scoreDocs.length);
-        assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
-        assertThat(context.queryResult().topDocs().topDocs, instanceOf(CollapseTopFieldDocs.class));
-
-        assertProfileData(context, "TermQuery", query -> {
-            assertThat(query.getTimeBreakdown().keySet(), not(empty()));
-            assertThat(query.getTimeBreakdown().get("score"), greaterThan(0L));
-            assertThat(query.getTimeBreakdown().get("score_count"), greaterThanOrEqualTo(6L));
-            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));
-            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) -> {
-            assertThat(profileResult.getQueryName(), equalTo(type));
-            assertThat(profileResult.getTime(), greaterThan(0L));
-            query.accept(profileResult);
-        });
-    }
-
-    private void assertProfileData(SearchContext context, Consumer<CollectorResult> collector, Consumer<ProfileResult> query1)
-        throws IOException {
-        assertProfileData(context, Arrays.asList(query1), collector, false);
-    }
-
-    private void assertProfileData(
-        SearchContext context,
-        Consumer<CollectorResult> collector,
-        Consumer<ProfileResult> query1,
-        Consumer<ProfileResult> query2
-    ) throws IOException {
-        assertProfileData(context, Arrays.asList(query1, query2), collector, false);
-    }
-
-    private final void assertProfileData(
-        SearchContext context,
-        List<Consumer<ProfileResult>> queries,
-        Consumer<CollectorResult> collector,
-        boolean debug
-    ) throws IOException {
-        assertThat(context.getProfilers(), not(nullValue()));
-
-        final ProfileShardResult result = SearchProfileShardResults.buildShardResults(context.getProfilers(), null);
-        if (debug) {
-            final SearchProfileShardResults results = new SearchProfileShardResults(
-                Collections.singletonMap(indexShard.shardId().toString(), result)
-            );
-
-            try (final XContentBuilder builder = JsonXContent.contentBuilder().prettyPrint()) {
-                builder.startObject();
-                results.toXContent(builder, ToXContent.EMPTY_PARAMS);
-                builder.endObject();
-                builder.flush();
-
-                final OutputStream out = builder.getOutputStream();
-                assertThat(out, instanceOf(ByteArrayOutputStream.class));
-
-                logger.info(new String(((ByteArrayOutputStream) out).toByteArray(), StandardCharsets.UTF_8));
-            }
-        }
-
-        assertThat(result.getQueryProfileResults(), hasSize(1));
-
-        final QueryProfileShardResult queryProfileShardResult = result.getQueryProfileResults().get(0);
-        assertThat(queryProfileShardResult.getQueryResults(), hasSize(queries.size()));
-
-        for (int i = 0; i < queries.size(); ++i) {
-            queries.get(i).accept(queryProfileShardResult.getQueryResults().get(i));
-        }
-
-        collector.accept(queryProfileShardResult.getCollectorResult());
-    }
-
-    private static ContextIndexSearcher newContextSearcher(IndexReader reader, ExecutorService executor) throws IOException {
-        return new ContextIndexSearcher(
-            reader,
-            IndexSearcher.getDefaultSimilarity(),
-            IndexSearcher.getDefaultQueryCache(),
-            IndexSearcher.getDefaultQueryCachingPolicy(),
-            true,
-            executor
-        );
-    }
-
-    private static ContextIndexSearcher newEarlyTerminationContextSearcher(IndexReader reader, int size, ExecutorService executor)
-        throws IOException {
-        return new ContextIndexSearcher(
-            reader,
-            IndexSearcher.getDefaultSimilarity(),
-            IndexSearcher.getDefaultQueryCache(),
-            IndexSearcher.getDefaultQueryCachingPolicy(),
-            true,
-            executor
-        ) {
-
-            @Override
-            public void search(List<LeafReaderContext> leaves, Weight weight, Collector collector) throws IOException {
-                final Collector in = new AssertingEarlyTerminationFilterCollector(collector, size);
-                super.search(leaves, weight, in);
-            }
-        };
-    }
-
-    private static class AssertingEarlyTerminationFilterCollector extends FilterCollector {
-        private final int size;
-
-        AssertingEarlyTerminationFilterCollector(Collector in, int size) {
-            super(in);
-            this.size = size;
-        }
-
-        @Override
-        public LeafCollector getLeafCollector(LeafReaderContext context) throws IOException {
-            final LeafCollector in = super.getLeafCollector(context);
-            return new FilterLeafCollector(in) {
-                int collected;
-
-                @Override
-                public void collect(int doc) throws IOException {
-                    assert collected <= size : "should not collect more than " + size + " doc per segment, got " + collected;
-                    ++collected;
-                    super.collect(doc);
-                }
-            };
-        }
-    }
-}
diff --git a/server/build.gradle b/server/build.gradle
index 235570d1778ff..44decd77d2f24 100644
--- a/server/build.gradle
+++ b/server/build.gradle
@@ -353,8 +353,14 @@ tasks.named("missingJavadoc").configure {
    */
   dependsOn("generateProto")
   javadocMissingIgnore = [
+    "org.opensearch.extensions.proto.ExtensionIdentityProto",
+    "org.opensearch.extensions.proto.ExtensionIdentityProto.ExtensionIdentityOrBuilder",
+    "org.opensearch.extensions.proto.RegisterRestActionsProto",
+    "org.opensearch.extensions.proto.RegisterRestActionsProto.RegisterRestActionsOrBuilder",
     "org.opensearch.extensions.proto.ExtensionRequestProto",
     "org.opensearch.extensions.proto.ExtensionRequestProto.ExtensionRequestOrBuilder",
+    "org.opensearch.extensions.proto.RegisterTransportActionsProto",
+    "org.opensearch.extensions.proto.RegisterTransportActionsProto.RegisterTransportActionsOrBuilder",
     "org.opensearch.extensions.proto"
   ]
 }
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 1fa9ef2f91712..cc1f8169afd3f 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
@@ -37,6 +37,7 @@
 import org.opensearch.action.admin.cluster.node.stats.NodeStats;
 import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequest;
 import org.opensearch.action.admin.cluster.node.stats.NodesStatsResponse;
+import org.opensearch.client.Client;
 import org.opensearch.client.Requests;
 import org.opensearch.cluster.health.ClusterHealthStatus;
 import org.opensearch.cluster.node.DiscoveryNodeRole;
@@ -152,11 +153,12 @@ public void testNodeCountsWithDeprecatedMasterRole() throws ExecutionException,
 
         Map<String, Integer> expectedCounts = getExpectedCounts(0, 1, 1, 0, 0, 0, 0);
 
-        ClusterStatsResponse response = client().admin().cluster().prepareClusterStats().get();
+        Client client = client();
+        ClusterStatsResponse response = client.admin().cluster().prepareClusterStats().get();
         assertCounts(response.getNodesStats().getCounts(), total, expectedCounts);
 
         Set<String> expectedRoles = Set.of(DiscoveryNodeRole.MASTER_ROLE.roleName());
-        assertEquals(expectedRoles, getNodeRoles(0));
+        assertEquals(expectedRoles, getNodeRoles(client, 0));
     }
 
     private static void incrementCountForRole(String role, Map<String, Integer> counts) {
@@ -327,14 +329,15 @@ public void testNodeRolesWithMasterLegacySettings() throws ExecutionException, I
 
         Map<String, Integer> expectedCounts = getExpectedCounts(0, 1, 1, 0, 1, 0, 0);
 
-        ClusterStatsResponse clusterStatsResponse = client().admin().cluster().prepareClusterStats().get();
+        Client client = client();
+        ClusterStatsResponse clusterStatsResponse = client.admin().cluster().prepareClusterStats().get();
         assertCounts(clusterStatsResponse.getNodesStats().getCounts(), total, expectedCounts);
 
         Set<String> expectedRoles = Set.of(
             DiscoveryNodeRole.MASTER_ROLE.roleName(),
             DiscoveryNodeRole.REMOTE_CLUSTER_CLIENT_ROLE.roleName()
         );
-        assertEquals(expectedRoles, getNodeRoles(0));
+        assertEquals(expectedRoles, getNodeRoles(client, 0));
     }
 
     public void testNodeRolesWithClusterManagerRole() throws ExecutionException, InterruptedException {
@@ -356,14 +359,15 @@ public void testNodeRolesWithClusterManagerRole() throws ExecutionException, Int
 
         Map<String, Integer> expectedCounts = getExpectedCounts(0, 1, 1, 0, 1, 0, 0);
 
-        ClusterStatsResponse clusterStatsResponse = client().admin().cluster().prepareClusterStats().get();
+        Client client = client();
+        ClusterStatsResponse clusterStatsResponse = client.admin().cluster().prepareClusterStats().get();
         assertCounts(clusterStatsResponse.getNodesStats().getCounts(), total, expectedCounts);
 
         Set<String> expectedRoles = Set.of(
             DiscoveryNodeRole.CLUSTER_MANAGER_ROLE.roleName(),
             DiscoveryNodeRole.REMOTE_CLUSTER_CLIENT_ROLE.roleName()
         );
-        assertEquals(expectedRoles, getNodeRoles(0));
+        assertEquals(expectedRoles, getNodeRoles(client, 0));
     }
 
     public void testNodeRolesWithSeedDataNodeLegacySettings() throws ExecutionException, InterruptedException {
@@ -379,7 +383,8 @@ public void testNodeRolesWithSeedDataNodeLegacySettings() throws ExecutionExcept
 
         Map<String, Integer> expectedRoleCounts = getExpectedCounts(1, 1, 1, 0, 1, 0, 0);
 
-        ClusterStatsResponse clusterStatsResponse = client().admin().cluster().prepareClusterStats().get();
+        Client client = client();
+        ClusterStatsResponse clusterStatsResponse = client.admin().cluster().prepareClusterStats().get();
         assertCounts(clusterStatsResponse.getNodesStats().getCounts(), total, expectedRoleCounts);
 
         Set<String> expectedRoles = Set.of(
@@ -387,7 +392,7 @@ public void testNodeRolesWithSeedDataNodeLegacySettings() throws ExecutionExcept
             DiscoveryNodeRole.REMOTE_CLUSTER_CLIENT_ROLE.roleName(),
             DiscoveryNodeRole.DATA_ROLE.roleName()
         );
-        assertEquals(expectedRoles, getNodeRoles(0));
+        assertEquals(expectedRoles, getNodeRoles(client, 0));
     }
 
     public void testNodeRolesWithDataNodeLegacySettings() throws ExecutionException, InterruptedException {
@@ -405,14 +410,15 @@ public void testNodeRolesWithDataNodeLegacySettings() throws ExecutionException,
 
         Map<String, Integer> expectedRoleCounts = getExpectedCounts(1, 1, 1, 0, 1, 0, 0);
 
-        ClusterStatsResponse clusterStatsResponse = client().admin().cluster().prepareClusterStats().get();
+        Client client = client();
+        ClusterStatsResponse clusterStatsResponse = client.admin().cluster().prepareClusterStats().get();
         assertCounts(clusterStatsResponse.getNodesStats().getCounts(), total, expectedRoleCounts);
 
         Set<Set<String>> expectedNodesRoles = Set.of(
             Set.of(DiscoveryNodeRole.CLUSTER_MANAGER_ROLE.roleName()),
             Set.of(DiscoveryNodeRole.DATA_ROLE.roleName(), DiscoveryNodeRole.REMOTE_CLUSTER_CLIENT_ROLE.roleName())
         );
-        assertEquals(expectedNodesRoles, Set.of(getNodeRoles(0), getNodeRoles(1)));
+        assertEquals(expectedNodesRoles, Set.of(getNodeRoles(client, 0), getNodeRoles(client, 1)));
     }
 
     private Map<String, Integer> getExpectedCounts(
@@ -435,8 +441,8 @@ private Map<String, Integer> getExpectedCounts(
         return expectedCounts;
     }
 
-    private Set<String> getNodeRoles(int nodeNumber) throws ExecutionException, InterruptedException {
-        NodesStatsResponse nodesStatsResponse = client().admin().cluster().nodesStats(new NodesStatsRequest()).get();
+    private Set<String> getNodeRoles(Client client, int nodeNumber) throws ExecutionException, InterruptedException {
+        NodesStatsResponse nodesStatsResponse = client.admin().cluster().nodesStats(new NodesStatsRequest()).get();
         return nodesStatsResponse.getNodes()
             .get(nodeNumber)
             .getNode()
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 5a3e4ef3bf0f1..e3e9fc569aee6 100644
--- a/server/src/internalClusterTest/java/org/opensearch/indices/replication/SegmentReplicationIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/indices/replication/SegmentReplicationIT.java
@@ -359,6 +359,7 @@ public void testClosedIndices() {
 
     /**
      * This test validates the primary node drop does not result in shard failure on replica.
+     * @throws Exception when issue is encountered
      */
     public void testNodeDropWithOngoingReplication() throws Exception {
         internalCluster().startClusterManagerOnlyNode();
@@ -868,6 +869,7 @@ public void testPressureServiceStats() throws Exception {
 
     /**
      * Tests a scroll query on the replica
+     * @throws Exception when issue is encountered
      */
     public void testScrollCreatedOnReplica() throws Exception {
         // create the cluster with one primary node containing primary shard and replica node containing replica shard
@@ -955,6 +957,8 @@ public void testScrollCreatedOnReplica() throws Exception {
     /**
      * Tests that when scroll query is cleared, it does not delete the temporary replication files, which are part of
      * ongoing round of segment replication
+     *
+     * @throws Exception when issue is encountered
      */
     public void testScrollWithOngoingSegmentReplication() throws Exception {
         // create the cluster with one primary node containing primary shard and replica node containing replica shard
diff --git a/server/src/main/java/org/opensearch/action/ActionModule.java b/server/src/main/java/org/opensearch/action/ActionModule.java
index 7346ccc2e3829..efbabf5f4a2a4 100644
--- a/server/src/main/java/org/opensearch/action/ActionModule.java
+++ b/server/src/main/java/org/opensearch/action/ActionModule.java
@@ -295,6 +295,7 @@
 import org.opensearch.extensions.action.ExtensionProxyAction;
 import org.opensearch.extensions.action.ExtensionProxyTransportAction;
 import org.opensearch.index.seqno.RetentionLeaseActions;
+import org.opensearch.identity.IdentityService;
 import org.opensearch.indices.SystemIndices;
 import org.opensearch.indices.breaker.CircuitBreakerService;
 import org.opensearch.persistent.CompletionPersistentTaskAction;
@@ -512,7 +513,8 @@ public ActionModule(
         NodeClient nodeClient,
         CircuitBreakerService circuitBreakerService,
         UsageService usageService,
-        SystemIndices systemIndices
+        SystemIndices systemIndices,
+        IdentityService identityService
     ) {
         this.settings = settings;
         this.indexNameExpressionResolver = indexNameExpressionResolver;
@@ -548,7 +550,7 @@ public ActionModule(
             actionPlugins.stream().flatMap(p -> p.indicesAliasesRequestValidators().stream()).collect(Collectors.toList())
         );
 
-        restController = new RestController(headers, restWrapper, nodeClient, circuitBreakerService, usageService);
+        restController = new RestController(headers, restWrapper, nodeClient, circuitBreakerService, usageService, identityService);
     }
 
     public Map<String, ActionHandler<?, ?>> getActions() {
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 0f819ad02bf0e..19a5808579d50 100644
--- a/server/src/main/java/org/opensearch/common/settings/FeatureFlagSettings.java
+++ b/server/src/main/java/org/opensearch/common/settings/FeatureFlagSettings.java
@@ -37,7 +37,9 @@ protected FeatureFlagSettings(
                 FeatureFlags.SEGMENT_REPLICATION_EXPERIMENTAL_SETTING,
                 FeatureFlags.REMOTE_STORE_SETTING,
                 FeatureFlags.EXTENSIONS_SETTING,
-                FeatureFlags.SEARCH_PIPELINE_SETTING
+                FeatureFlags.IDENTITY_SETTING,
+                FeatureFlags.SEARCH_PIPELINE_SETTING,
+                FeatureFlags.CONCURRENT_SEGMENT_SEARCH_SETTING
             )
         )
     );
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 34d0feeaeb525..a26b4006bb31e 100644
--- a/server/src/main/java/org/opensearch/common/util/FeatureFlags.java
+++ b/server/src/main/java/org/opensearch/common/util/FeatureFlags.java
@@ -52,6 +52,17 @@ public class FeatureFlags {
      */
     public static final String SEARCH_PIPELINE = "opensearch.experimental.feature.search_pipeline.enabled";
 
+    /**
+     * Gates the functionality of identity.
+     */
+    public static final String IDENTITY = "opensearch.experimental.feature.identity.enabled";
+
+    /**
+     * Gates the functionality of concurrently searching the segments
+     * Once the feature is ready for release, this feature flag can be removed.
+     */
+    public static final String CONCURRENT_SEGMENT_SEARCH = "opensearch.experimental.feature.concurrent_segment_search.enabled";
+
     /**
      * Should store the settings from opensearch.yml.
      */
@@ -91,4 +102,12 @@ public static boolean isEnabled(String featureFlagName) {
     public static final Setting<Boolean> EXTENSIONS_SETTING = Setting.boolSetting(EXTENSIONS, false, Property.NodeScope);
 
     public static final Setting<Boolean> SEARCH_PIPELINE_SETTING = Setting.boolSetting(SEARCH_PIPELINE, false, Property.NodeScope);
+
+    public static final Setting<Boolean> IDENTITY_SETTING = Setting.boolSetting(IDENTITY, false, Property.NodeScope);
+
+    public static final Setting<Boolean> CONCURRENT_SEGMENT_SEARCH_SETTING = Setting.boolSetting(
+        CONCURRENT_SEGMENT_SEARCH,
+        false,
+        Property.NodeScope
+    );
 }
diff --git a/server/src/main/java/org/opensearch/extensions/ExtensionRequest.java b/server/src/main/java/org/opensearch/extensions/ExtensionRequest.java
index 07d055bf54d97..cd2dc99b8de93 100644
--- a/server/src/main/java/org/opensearch/extensions/ExtensionRequest.java
+++ b/server/src/main/java/org/opensearch/extensions/ExtensionRequest.java
@@ -13,6 +13,7 @@
 import org.opensearch.common.Nullable;
 import org.opensearch.common.io.stream.StreamInput;
 import org.opensearch.common.io.stream.StreamOutput;
+import org.opensearch.extensions.proto.ExtensionIdentityProto;
 import org.opensearch.extensions.proto.ExtensionRequestProto;
 import org.opensearch.transport.TransportRequest;
 
@@ -35,7 +36,7 @@ public ExtensionRequest(ExtensionRequestProto.RequestType requestType) {
     public ExtensionRequest(ExtensionRequestProto.RequestType requestType, @Nullable String uniqueId) {
         ExtensionRequestProto.ExtensionRequest.Builder builder = ExtensionRequestProto.ExtensionRequest.newBuilder();
         if (uniqueId != null) {
-            builder.setUniqueId(uniqueId);
+            builder.setIdentity(ExtensionIdentityProto.ExtensionIdentity.newBuilder().setUniqueId(uniqueId).build());
         }
         this.request = builder.setRequestType(requestType).build();
     }
@@ -56,24 +57,28 @@ public ExtensionRequestProto.RequestType getRequestType() {
     }
 
     public String getUniqueId() {
-        return request.getUniqueId();
+        return request.getIdentity().getUniqueId();
     }
 
     public String toString() {
         return "ExtensionRequest{" + request.toString() + '}';
     }
 
+    public ExtensionIdentityProto.ExtensionIdentity getExtensionIdentity() {
+        return request.getIdentity();
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
         ExtensionRequest that = (ExtensionRequest) o;
         return Objects.equals(request.getRequestType(), that.request.getRequestType())
-            && Objects.equals(request.getUniqueId(), that.request.getUniqueId());
+            && Objects.equals(request.getIdentity().getUniqueId(), that.request.getIdentity().getUniqueId());
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(request.getRequestType(), request.getUniqueId());
+        return Objects.hash(request.getRequestType(), request.getIdentity().getUniqueId());
     }
 }
diff --git a/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java b/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java
index 0edc215e536a3..94ad9ff84cfdb 100644
--- a/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java
+++ b/server/src/main/java/org/opensearch/extensions/ExtensionsManager.java
@@ -19,6 +19,7 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionException;
 import java.util.concurrent.TimeUnit;
@@ -107,8 +108,7 @@ public static enum OpenSearchRequestType {
 
     private final Path extensionsPath;
     private ExtensionTransportActionsHandler extensionTransportActionsHandler;
-    // A list of initialized extensions, a subset of the values of map below which includes all extensions
-    private List<DiscoveryExtensionNode> extensions;
+    private Map<String, DiscoveryExtensionNode> initializedExtensions;
     private Map<String, DiscoveryExtensionNode> extensionIdMap;
     private RestActionsRequestHandler restActionsRequestHandler;
     private CustomSettingsRequestHandler customSettingsRequestHandler;
@@ -118,21 +118,16 @@ public static enum OpenSearchRequestType {
     private AddSettingsUpdateConsumerRequestHandler addSettingsUpdateConsumerRequestHandler;
     private NodeClient client;
 
-    public ExtensionsManager() {
-        this.extensionsPath = Path.of("");
-    }
-
     /**
      * Instantiate a new ExtensionsManager object to handle requests and responses from extensions. This is called during Node bootstrap.
      *
-     * @param settings  Settings from the node the orchestrator is running on.
      * @param extensionsPath  Path to a directory containing extensions.
      * @throws IOException  If the extensions discovery file is not properly retrieved.
      */
-    public ExtensionsManager(Settings settings, Path extensionsPath) throws IOException {
+    public ExtensionsManager(Path extensionsPath) throws IOException {
         logger.info("ExtensionsManager initialized");
         this.extensionsPath = extensionsPath;
-        this.extensions = new ArrayList<DiscoveryExtensionNode>();
+        this.initializedExtensions = new HashMap<String, DiscoveryExtensionNode>();
         this.extensionIdMap = new HashMap<String, DiscoveryExtensionNode>();
         // will be initialized in initializeServicesAndRestHandler which is called after the Node is initialized
         this.transportService = null;
@@ -187,6 +182,16 @@ public void initializeServicesAndRestHandler(
         registerRequestHandler();
     }
 
+    /**
+     * Lookup an initialized extension by its unique id
+     *
+     * @param extensionId The unique extension identifier
+     * @return An optional of the DiscoveryExtensionNode instance for the matching extension
+     */
+    public Optional<DiscoveryExtensionNode> lookupInitializedExtensionById(final String extensionId) {
+        return Optional.ofNullable(this.initializedExtensions.get(extensionId));
+    }
+
     /**
      * Handles Transport Request from {@link org.opensearch.extensions.action.ExtensionTransportAction} which was invoked by an extension via {@link ExtensionTransportActionsHandler}.
      *
@@ -289,7 +294,7 @@ private void registerRequestHandler() {
     /*
      * Load and populate all extensions
      */
-    private void discover() throws IOException {
+    protected void discover() throws IOException {
         logger.info("Loading extensions : {}", extensionsPath);
         if (!FileSystemUtils.isAccessibleDirectory(extensionsPath, logger)) {
             return;
@@ -342,7 +347,7 @@ private void loadExtension(Extension extension) throws IOException {
     }
 
     /**
-     * Iterate through all extensions and initialize them.  Initialized extensions will be added to the {@link #extensions}.
+     * Iterate through all extensions and initialize them.  Initialized extensions will be added to the {@link #initializedExtensions}.
      */
     public void initialize() {
         for (DiscoveryExtensionNode extension : extensionIdMap.values()) {
@@ -366,7 +371,7 @@ public void handleResponse(InitializeExtensionResponse response) {
                 for (DiscoveryExtensionNode extension : extensionIdMap.values()) {
                     if (extension.getName().equals(response.getName())) {
                         extension.setImplementedInterfaces(response.getImplementedInterfaces());
-                        extensions.add(extension);
+                        initializedExtensions.put(extension.getId(), extension);
                         logger.info("Initialized extension: " + extension.getName());
                         break;
                     }
@@ -426,11 +431,17 @@ TransportResponse handleExtensionRequest(ExtensionRequest extensionRequest) thro
             case REQUEST_EXTENSION_DEPENDENCY_INFORMATION:
                 String uniqueId = extensionRequest.getUniqueId();
                 if (uniqueId == null) {
-                    return new ExtensionDependencyResponse(extensions);
+                    return new ExtensionDependencyResponse(
+                        initializedExtensions.entrySet().stream().map(e -> e.getValue()).collect(Collectors.toList())
+                    );
                 } else {
                     ExtensionDependency matchingId = new ExtensionDependency(uniqueId, Version.CURRENT);
                     return new ExtensionDependencyResponse(
-                        extensions.stream().filter(e -> e.dependenciesContain(matchingId)).collect(Collectors.toList())
+                        initializedExtensions.entrySet()
+                            .stream()
+                            .map(e -> e.getValue())
+                            .filter(e -> e.dependenciesContain(matchingId))
+                            .collect(Collectors.toList())
                     );
                 }
             default:
@@ -623,154 +634,83 @@ private ExtensionsSettings readFromExtensionsYml(Path filePath) throws IOExcepti
         }
     }
 
-    public static String getRequestExtensionActionName() {
+    static String getRequestExtensionActionName() {
         return REQUEST_EXTENSION_ACTION_NAME;
     }
 
-    public static String getIndicesExtensionPointActionName() {
+    static String getIndicesExtensionPointActionName() {
         return INDICES_EXTENSION_POINT_ACTION_NAME;
     }
 
-    public static String getIndicesExtensionNameActionName() {
+    static String getIndicesExtensionNameActionName() {
         return INDICES_EXTENSION_NAME_ACTION_NAME;
     }
 
-    public static String getRequestExtensionClusterState() {
+    static String getRequestExtensionClusterState() {
         return REQUEST_EXTENSION_CLUSTER_STATE;
     }
 
-    public static String getRequestExtensionClusterSettings() {
+    static String getRequestExtensionClusterSettings() {
         return REQUEST_EXTENSION_CLUSTER_SETTINGS;
     }
 
-    public static Logger getLogger() {
+    static Logger getLogger() {
         return logger;
     }
 
-    public Path getExtensionsPath() {
+    Path getExtensionsPath() {
         return extensionsPath;
     }
 
-    public List<DiscoveryExtensionNode> getExtensions() {
-        return extensions;
-    }
-
-    public TransportService getTransportService() {
+    TransportService getTransportService() {
         return transportService;
     }
 
-    public ClusterService getClusterService() {
+    ClusterService getClusterService() {
         return clusterService;
     }
 
-    public static String getRequestExtensionRegisterRestActions() {
-        return REQUEST_EXTENSION_REGISTER_REST_ACTIONS;
-    }
-
-    public static String getRequestRestExecuteOnExtensionAction() {
-        return REQUEST_REST_EXECUTE_ON_EXTENSION_ACTION;
-    }
-
-    public Map<String, DiscoveryExtensionNode> getExtensionIdMap() {
+    Map<String, DiscoveryExtensionNode> getExtensionIdMap() {
         return extensionIdMap;
     }
 
-    public RestActionsRequestHandler getRestActionsRequestHandler() {
+    RestActionsRequestHandler getRestActionsRequestHandler() {
         return restActionsRequestHandler;
     }
 
-    public void setExtensions(List<DiscoveryExtensionNode> extensions) {
-        this.extensions = extensions;
-    }
-
-    public void setExtensionIdMap(Map<String, DiscoveryExtensionNode> extensionIdMap) {
+    void setExtensionIdMap(Map<String, DiscoveryExtensionNode> extensionIdMap) {
         this.extensionIdMap = extensionIdMap;
     }
 
-    public void setRestActionsRequestHandler(RestActionsRequestHandler restActionsRequestHandler) {
+    void setRestActionsRequestHandler(RestActionsRequestHandler restActionsRequestHandler) {
         this.restActionsRequestHandler = restActionsRequestHandler;
     }
 
-    public void setTransportService(TransportService transportService) {
+    void setTransportService(TransportService transportService) {
         this.transportService = transportService;
     }
 
-    public void setClusterService(ClusterService clusterService) {
+    void setClusterService(ClusterService clusterService) {
         this.clusterService = clusterService;
     }
 
-    public static String getRequestExtensionRegisterTransportActions() {
-        return REQUEST_EXTENSION_REGISTER_TRANSPORT_ACTIONS;
-    }
-
-    public static String getRequestExtensionRegisterCustomSettings() {
-        return REQUEST_EXTENSION_REGISTER_CUSTOM_SETTINGS;
-    }
-
-    public CustomSettingsRequestHandler getCustomSettingsRequestHandler() {
+    CustomSettingsRequestHandler getCustomSettingsRequestHandler() {
         return customSettingsRequestHandler;
     }
 
-    public void setCustomSettingsRequestHandler(CustomSettingsRequestHandler customSettingsRequestHandler) {
+    void setCustomSettingsRequestHandler(CustomSettingsRequestHandler customSettingsRequestHandler) {
         this.customSettingsRequestHandler = customSettingsRequestHandler;
     }
 
-    public static String getRequestExtensionEnvironmentSettings() {
-        return REQUEST_EXTENSION_ENVIRONMENT_SETTINGS;
-    }
-
-    public static String getRequestExtensionAddSettingsUpdateConsumer() {
-        return REQUEST_EXTENSION_ADD_SETTINGS_UPDATE_CONSUMER;
-    }
-
-    public static String getRequestExtensionUpdateSettings() {
-        return REQUEST_EXTENSION_UPDATE_SETTINGS;
-    }
-
-    public AddSettingsUpdateConsumerRequestHandler getAddSettingsUpdateConsumerRequestHandler() {
+    AddSettingsUpdateConsumerRequestHandler getAddSettingsUpdateConsumerRequestHandler() {
         return addSettingsUpdateConsumerRequestHandler;
     }
 
-    public void setAddSettingsUpdateConsumerRequestHandler(
-        AddSettingsUpdateConsumerRequestHandler addSettingsUpdateConsumerRequestHandler
-    ) {
+    void setAddSettingsUpdateConsumerRequestHandler(AddSettingsUpdateConsumerRequestHandler addSettingsUpdateConsumerRequestHandler) {
         this.addSettingsUpdateConsumerRequestHandler = addSettingsUpdateConsumerRequestHandler;
     }
 
-    public Settings getEnvironmentSettings() {
+    Settings getEnvironmentSettings() {
         return environmentSettings;
     }
-
-    public void setEnvironmentSettings(Settings environmentSettings) {
-        this.environmentSettings = environmentSettings;
-    }
-
-    public static String getRequestExtensionHandleTransportAction() {
-        return REQUEST_EXTENSION_HANDLE_TRANSPORT_ACTION;
-    }
-
-    public static String getTransportActionRequestFromExtension() {
-        return TRANSPORT_ACTION_REQUEST_FROM_EXTENSION;
-    }
-
-    public static int getExtensionRequestWaitTimeout() {
-        return EXTENSION_REQUEST_WAIT_TIMEOUT;
-    }
-
-    public ExtensionTransportActionsHandler getExtensionTransportActionsHandler() {
-        return extensionTransportActionsHandler;
-    }
-
-    public void setExtensionTransportActionsHandler(ExtensionTransportActionsHandler extensionTransportActionsHandler) {
-        this.extensionTransportActionsHandler = extensionTransportActionsHandler;
-    }
-
-    public NodeClient getClient() {
-        return client;
-    }
-
-    public void setClient(NodeClient client) {
-        this.client = client;
-    }
-
 }
diff --git a/server/src/main/java/org/opensearch/extensions/NoopExtensionsManager.java b/server/src/main/java/org/opensearch/extensions/NoopExtensionsManager.java
index 24f71476dcb1e..6165423b767ce 100644
--- a/server/src/main/java/org/opensearch/extensions/NoopExtensionsManager.java
+++ b/server/src/main/java/org/opensearch/extensions/NoopExtensionsManager.java
@@ -8,6 +8,23 @@
 
 package org.opensearch.extensions;
 
+import java.io.IOException;
+import java.net.UnknownHostException;
+import java.nio.file.Path;
+import java.util.Optional;
+
+import org.opensearch.action.ActionModule;
+import org.opensearch.client.node.NodeClient;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.settings.SettingsModule;
+
+import org.opensearch.extensions.action.ExtensionActionRequest;
+import org.opensearch.extensions.action.ExtensionActionResponse;
+import org.opensearch.extensions.action.RemoteExtensionActionResponse;
+import org.opensearch.index.IndexModule;
+import org.opensearch.transport.TransportService;
+
 /**
  * Noop class for ExtensionsManager
  *
@@ -15,7 +32,52 @@
  */
 public class NoopExtensionsManager extends ExtensionsManager {
 
-    public NoopExtensionsManager() {
-        super();
+    public NoopExtensionsManager() throws IOException {
+        super(Path.of(""));
+    }
+
+    @Override
+    public void initializeServicesAndRestHandler(
+        ActionModule actionModule,
+        SettingsModule settingsModule,
+        TransportService transportService,
+        ClusterService clusterService,
+        Settings initialEnvironmentSettings,
+        NodeClient client
+    ) {
+        // no-op
+    }
+
+    @Override
+    public RemoteExtensionActionResponse handleRemoteTransportRequest(ExtensionActionRequest request) throws Exception {
+        // no-op empty response
+        return new RemoteExtensionActionResponse(true, new byte[0]);
+    }
+
+    @Override
+    public ExtensionActionResponse handleTransportRequest(ExtensionActionRequest request) throws Exception {
+        // no-op empty response
+        return new ExtensionActionResponse(new byte[0]);
+    }
+
+    @Override
+    protected void discover() throws IOException {
+        // no-op
+    }
+
+    @Override
+    public void initialize() {
+        // no-op
+    }
+
+    @Override
+    public void onIndexModule(IndexModule indexModule) throws UnknownHostException {
+        // no-op
+    }
+
+    @Override
+    public Optional<DiscoveryExtensionNode> lookupInitializedExtensionById(final String extensionId) {
+        // no-op not found
+        return Optional.empty();
     }
 }
diff --git a/server/src/main/java/org/opensearch/extensions/action/RegisterTransportActionsRequest.java b/server/src/main/java/org/opensearch/extensions/action/RegisterTransportActionsRequest.java
index be711ee69dea6..acfacac051803 100644
--- a/server/src/main/java/org/opensearch/extensions/action/RegisterTransportActionsRequest.java
+++ b/server/src/main/java/org/opensearch/extensions/action/RegisterTransportActionsRequest.java
@@ -10,10 +10,12 @@
 
 import org.opensearch.common.io.stream.StreamInput;
 import org.opensearch.common.io.stream.StreamOutput;
+import org.opensearch.extensions.proto.RegisterTransportActionsProto.RegisterTransportActions;
+import org.opensearch.extensions.proto.ExtensionIdentityProto.ExtensionIdentity;
 import org.opensearch.transport.TransportRequest;
 
 import java.io.IOException;
-import java.util.HashSet;
+import java.util.List;
 import java.util.Objects;
 import java.util.Set;
 
@@ -23,40 +25,35 @@
  * @opensearch.internal
  */
 public class RegisterTransportActionsRequest extends TransportRequest {
-    // The uniqueId defining the extension which runs this action
-    private String uniqueId;
-    // The action names to register
-    private Set<String> transportActions;
+    private final RegisterTransportActions request;
 
     public RegisterTransportActionsRequest(String uniqueId, Set<String> transportActions) {
-        this.uniqueId = uniqueId;
-        this.transportActions = transportActions;
+        ExtensionIdentity identity = ExtensionIdentity.newBuilder().setUniqueId(uniqueId).build();
+        this.request = RegisterTransportActions.newBuilder().setIdentity(identity).addAllTransportActions(transportActions).build();
     }
 
     public RegisterTransportActionsRequest(StreamInput in) throws IOException {
         super(in);
-        this.uniqueId = in.readString();
-        this.transportActions = new HashSet<>(in.readStringList());
+        this.request = RegisterTransportActions.parseFrom(in.readByteArray());
     }
 
     public String getUniqueId() {
-        return uniqueId;
+        return request.getIdentity().getUniqueId();
     }
 
-    public Set<String> getTransportActions() {
-        return transportActions;
+    public List<String> getTransportActions() {
+        return request.getTransportActionsList();
     }
 
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         super.writeTo(out);
-        out.writeString(uniqueId);
-        out.writeStringCollection(transportActions);
+        out.writeByteArray(request.toByteArray());
     }
 
     @Override
     public String toString() {
-        return "TransportActionsRequest{uniqueId=" + uniqueId + ", actions=" + transportActions + "}";
+        return "TransportActionsRequest{Identity=" + request.getIdentity() + ", actions=" + request.getTransportActionsList() + "}";
     }
 
     @Override
@@ -64,11 +61,12 @@ public boolean equals(Object obj) {
         if (this == obj) return true;
         if (obj == null || getClass() != obj.getClass()) return false;
         RegisterTransportActionsRequest that = (RegisterTransportActionsRequest) obj;
-        return Objects.equals(uniqueId, that.uniqueId) && Objects.equals(transportActions, that.transportActions);
+        return Objects.equals(request.getIdentity().getUniqueId(), that.request.getIdentity().getUniqueId())
+            && Objects.equals(request.getTransportActionsList(), that.request.getTransportActionsList());
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(uniqueId, transportActions);
+        return Objects.hash(request.getIdentity(), request.getTransportActionsList());
     }
 }
diff --git a/server/src/main/java/org/opensearch/extensions/rest/RegisterRestActionsRequest.java b/server/src/main/java/org/opensearch/extensions/rest/RegisterRestActionsRequest.java
index fddeb7dff1909..d518f4c83fd30 100644
--- a/server/src/main/java/org/opensearch/extensions/rest/RegisterRestActionsRequest.java
+++ b/server/src/main/java/org/opensearch/extensions/rest/RegisterRestActionsRequest.java
@@ -10,10 +10,11 @@
 
 import org.opensearch.common.io.stream.StreamInput;
 import org.opensearch.common.io.stream.StreamOutput;
+import org.opensearch.extensions.proto.ExtensionIdentityProto.ExtensionIdentity;
+import org.opensearch.extensions.proto.RegisterRestActionsProto.RegisterRestActions;
 import org.opensearch.transport.TransportRequest;
 
 import java.io.IOException;
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
 
@@ -23,51 +24,48 @@
  * @opensearch.internal
  */
 public class RegisterRestActionsRequest extends TransportRequest {
-    private String uniqueId;
-    private List<String> restActions;
-    private List<String> deprecatedRestActions;
+    private final RegisterRestActions request;
 
     public RegisterRestActionsRequest(String uniqueId, List<String> restActions, List<String> deprecatedRestActions) {
-        this.uniqueId = uniqueId;
-        this.restActions = new ArrayList<>(restActions);
-        this.deprecatedRestActions = new ArrayList<>(deprecatedRestActions);
+        ExtensionIdentity identity = ExtensionIdentity.newBuilder().setUniqueId(uniqueId).build();
+        this.request = RegisterRestActions.newBuilder()
+            .setIdentity(identity)
+            .addAllRestActions(restActions)
+            .addAllDeprecatedRestActions(deprecatedRestActions)
+            .build();
     }
 
     public RegisterRestActionsRequest(StreamInput in) throws IOException {
         super(in);
-        uniqueId = in.readString();
-        restActions = in.readStringList();
-        deprecatedRestActions = in.readStringList();
+        request = RegisterRestActions.parseFrom(in.readByteArray());
     }
 
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         super.writeTo(out);
-        out.writeString(uniqueId);
-        out.writeStringCollection(restActions);
-        out.writeStringCollection(deprecatedRestActions);
+        out.writeByteArray(request.toByteArray());
     }
 
     public String getUniqueId() {
-        return uniqueId;
+        return request.getIdentity().getUniqueId();
     }
 
     public List<String> getRestActions() {
-        return List.copyOf(restActions);
+        return List.copyOf(request.getRestActionsList());
     }
 
     public List<String> getDeprecatedRestActions() {
-        return List.copyOf(deprecatedRestActions);
+        return List.copyOf(request.getDeprecatedRestActionsList());
     }
 
     @Override
     public String toString() {
-        return "RestActionsRequest{uniqueId="
-            + uniqueId
+        return "RestActionsRequest{Identity="
+            + request.getIdentity()
             + ", restActions="
-            + restActions
+            + request.getRestActionsList()
             + ", deprecatedRestActions="
-            + deprecatedRestActions
+            + request.getDeprecatedRestActionsList()
             + "}";
     }
 
@@ -76,13 +74,13 @@ public boolean equals(Object obj) {
         if (this == obj) return true;
         if (obj == null || getClass() != obj.getClass()) return false;
         RegisterRestActionsRequest that = (RegisterRestActionsRequest) obj;
-        return Objects.equals(uniqueId, that.uniqueId)
-            && Objects.equals(restActions, that.restActions)
-            && Objects.equals(deprecatedRestActions, that.deprecatedRestActions);
+        return Objects.equals(request.getIdentity().getUniqueId(), that.request.getIdentity().getUniqueId())
+            && Objects.equals(request.getRestActionsList(), that.request.getRestActionsList())
+            && Objects.equals(request.getDeprecatedRestActionsList(), that.request.getDeprecatedRestActionsList());
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(uniqueId, restActions, deprecatedRestActions);
+        return Objects.hash(request.getIdentity(), request.getRestActionsList(), request.getDeprecatedRestActionsList());
     }
 }
diff --git a/server/src/main/java/org/opensearch/identity/IdentityService.java b/server/src/main/java/org/opensearch/identity/IdentityService.java
new file mode 100644
index 0000000000000..e7e785ba75231
--- /dev/null
+++ b/server/src/main/java/org/opensearch/identity/IdentityService.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.identity;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.OpenSearchException;
+import org.opensearch.identity.noop.NoopIdentityPlugin;
+import java.util.List;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.plugins.IdentityPlugin;
+import java.util.stream.Collectors;
+
+/**
+ * Identity and access control for OpenSearch.
+ *
+ * @opensearch.experimental
+ * */
+public class IdentityService {
+    private static final Logger log = LogManager.getLogger(IdentityService.class);
+
+    private final Settings settings;
+    private final IdentityPlugin identityPlugin;
+
+    public IdentityService(final Settings settings, final List<IdentityPlugin> identityPlugins) {
+        this.settings = settings;
+
+        if (identityPlugins.size() == 0) {
+            log.debug("Identity plugins size is 0");
+            identityPlugin = new NoopIdentityPlugin();
+        } else if (identityPlugins.size() == 1) {
+            log.debug("Identity plugins size is 1");
+            identityPlugin = identityPlugins.get(0);
+        } else {
+            throw new OpenSearchException(
+                "Multiple identity plugins are not supported, found: "
+                    + identityPlugins.stream().map(Object::getClass).map(Class::getName).collect(Collectors.joining(","))
+            );
+        }
+    }
+
+    /**
+     * Gets the current subject
+     */
+    public Subject getSubject() {
+        return identityPlugin.getSubject();
+    }
+}
diff --git a/server/src/main/java/org/opensearch/identity/NamedPrincipal.java b/server/src/main/java/org/opensearch/identity/NamedPrincipal.java
new file mode 100644
index 0000000000000..f30d307bdf592
--- /dev/null
+++ b/server/src/main/java/org/opensearch/identity/NamedPrincipal.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.identity;
+
+import java.security.Principal;
+import java.util.Objects;
+
+/**
+ * Create a principal from a string
+ *
+ * @opensearch.experimental
+ */
+public class NamedPrincipal implements Principal {
+
+    /**
+     * Represents a principal which has not been authenticated
+     */
+    public static final NamedPrincipal UNAUTHENTICATED = new NamedPrincipal("Unauthenticated");
+
+    private final String name;
+
+    /**
+     * Creates a principal for an identity specified as a string
+     * @param name A persistent string that represent an identity
+     */
+    public NamedPrincipal(final String name) {
+        this.name = name;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public boolean equals(final Object obj) {
+        if (this == obj) return true;
+        if (obj == null || getClass() != obj.getClass()) return false;
+        final Principal that = (Principal) obj;
+        return Objects.equals(name, that.getName());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name);
+    }
+
+    @Override
+    public String toString() {
+        return "NamedPrincipal(" + "name=" + name + ")";
+    }
+}
diff --git a/server/src/main/java/org/opensearch/identity/Subject.java b/server/src/main/java/org/opensearch/identity/Subject.java
new file mode 100644
index 0000000000000..cbfdadb5cf6a7
--- /dev/null
+++ b/server/src/main/java/org/opensearch/identity/Subject.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.identity;
+
+import org.opensearch.identity.tokens.AuthToken;
+
+import java.security.Principal;
+
+/**
+ * An individual, process, or device that causes information to flow among objects or change to the system state.
+ *
+ * @opensearch.experimental
+ */
+public interface Subject {
+
+    /**
+     * Get the application-wide uniquely identifying principal
+     * */
+    Principal getPrincipal();
+
+    /**
+     * 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
new file mode 100644
index 0000000000000..437c059684565
--- /dev/null
+++ b/server/src/main/java/org/opensearch/identity/noop/NoopIdentityPlugin.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.identity.noop;
+
+import org.opensearch.plugins.IdentityPlugin;
+import org.opensearch.identity.Subject;
+
+/**
+ * Implementation of identity plugin that does not enforce authentication or authorization
+ *
+ * This class and related classes in this package will not return nulls or fail access checks
+ *
+ * @opensearch.internal
+ */
+public class NoopIdentityPlugin implements IdentityPlugin {
+
+    /**
+     * Get the current subject
+     * @return Must never return null
+     */
+    @Override
+    public Subject getSubject() {
+        return new NoopSubject();
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/identity/noop/NoopSubject.java b/server/src/main/java/org/opensearch/identity/noop/NoopSubject.java
new file mode 100644
index 0000000000000..801225fb16ad3
--- /dev/null
+++ b/server/src/main/java/org/opensearch/identity/noop/NoopSubject.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.identity.noop;
+
+import java.security.Principal;
+import java.util.Objects;
+
+import org.opensearch.identity.NamedPrincipal;
+import org.opensearch.identity.tokens.AuthToken;
+import org.opensearch.identity.Subject;
+
+/**
+ * Implementation of subject that is always authenticated
+ *
+ * This class and related classes in this package will not return nulls or fail permissions checks
+ *
+ * @opensearch.internal
+ */
+public class NoopSubject implements Subject {
+
+    @Override
+    public Principal getPrincipal() {
+        return NamedPrincipal.UNAUTHENTICATED;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (obj == null || getClass() != obj.getClass()) return false;
+        Subject that = (Subject) obj;
+        return Objects.equals(getPrincipal(), that.getPrincipal());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(getPrincipal());
+    }
+
+    @Override
+    public String toString() {
+        return "NoopSubject(principal=" + getPrincipal() + ")";
+    }
+
+    /**
+     * Logs the user in
+     */
+    @Override
+    public void authenticate(AuthToken AuthToken) {
+        // Do nothing as noop subject is always logged in
+    }
+}
diff --git a/server/src/main/java/org/opensearch/identity/noop/package-info.java b/server/src/main/java/org/opensearch/identity/noop/package-info.java
new file mode 100644
index 0000000000000..fcdd70db7f020
--- /dev/null
+++ b/server/src/main/java/org/opensearch/identity/noop/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.
+ */
+
+/** Classes for the noop authentication in OpenSearch */
+package org.opensearch.identity.noop;
diff --git a/server/src/main/java/org/opensearch/identity/package-info.java b/server/src/main/java/org/opensearch/identity/package-info.java
new file mode 100644
index 0000000000000..4693206af62a5
--- /dev/null
+++ b/server/src/main/java/org/opensearch/identity/package-info.java
@@ -0,0 +1,7 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/** Core identity and access controls for OpenSearch */
+package org.opensearch.identity;
diff --git a/server/src/main/java/org/opensearch/identity/tokens/AuthToken.java b/server/src/main/java/org/opensearch/identity/tokens/AuthToken.java
new file mode 100644
index 0000000000000..6e113f6eaa96a
--- /dev/null
+++ b/server/src/main/java/org/opensearch/identity/tokens/AuthToken.java
@@ -0,0 +1,18 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch 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.tokens;
+
+/**
+ * Interface for all token formats to support to authenticate user such as UserName/Password tokens, Access tokens, and more.
+ *
+ * @opensearch.experimental
+ */
+public interface AuthToken {
+
+}
diff --git a/server/src/main/java/org/opensearch/identity/tokens/BasicAuthToken.java b/server/src/main/java/org/opensearch/identity/tokens/BasicAuthToken.java
new file mode 100644
index 0000000000000..e5000cb3d6965
--- /dev/null
+++ b/server/src/main/java/org/opensearch/identity/tokens/BasicAuthToken.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.identity.tokens;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+
+/**
+ * Basic (Base64 encoded) Authentication Token in a http request header
+ */
+public final class BasicAuthToken implements AuthToken {
+
+    public final static String TOKEN_IDENIFIER = "Basic";
+
+    private String user;
+    private String password;
+
+    public BasicAuthToken(final String headerValue) {
+        final String base64Encoded = headerValue.substring(TOKEN_IDENIFIER.length()).trim();
+        final byte[] rawDecoded = Base64.getDecoder().decode(base64Encoded);
+        final String usernamepassword = new String(rawDecoded, StandardCharsets.UTF_8);
+
+        final String[] tokenParts = usernamepassword.split(":", 2);
+        if (tokenParts.length != 2) {
+            throw new IllegalStateException("Illegally formed basic authorization header " + tokenParts[0]);
+        }
+        user = tokenParts[0];
+        password = tokenParts[1];
+    }
+
+    public String getUser() {
+        return user;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/identity/tokens/RestTokenExtractor.java b/server/src/main/java/org/opensearch/identity/tokens/RestTokenExtractor.java
new file mode 100644
index 0000000000000..eaeacdb240fd9
--- /dev/null
+++ b/server/src/main/java/org/opensearch/identity/tokens/RestTokenExtractor.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.identity.tokens;
+
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.LogManager;
+import org.opensearch.common.Strings;
+import org.opensearch.rest.RestRequest;
+
+import java.util.Collections;
+import java.util.Optional;
+
+/**
+ * Extracts tokens from RestRequests used for authentication
+ */
+public class RestTokenExtractor {
+
+    private static final Logger logger = LogManager.getLogger(RestTokenExtractor.class);
+
+    public final static String AUTH_HEADER_NAME = "Authorization";
+
+    /**
+     * Given a rest request it will extract authentication token
+     *
+     * If no token was found, returns null.
+     */
+    public static AuthToken extractToken(final RestRequest request) {
+
+        // Extract authentication information from headers
+        final Optional<String> authHeaderValue = request.getHeaders()
+            .getOrDefault(AUTH_HEADER_NAME, Collections.emptyList())
+            .stream()
+            .findFirst();
+
+        if (authHeaderValue.isPresent()) {
+            final String authHeaderValueStr = authHeaderValue.get();
+
+            if (authHeaderValueStr.startsWith(BasicAuthToken.TOKEN_IDENIFIER)) {
+                return new BasicAuthToken(authHeaderValueStr);
+            } else {
+                if (logger.isDebugEnabled()) {
+                    String tokenTypeTruncated = Strings.substring(authHeaderValueStr, 0, 5);
+                    logger.debug("An authentication header was detected but the token type was not supported " + tokenTypeTruncated);
+                }
+            }
+        }
+
+        logger.trace("No auth token could be extracted");
+        return null;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/identity/tokens/package-info.java b/server/src/main/java/org/opensearch/identity/tokens/package-info.java
new file mode 100644
index 0000000000000..b63ea40c61659
--- /dev/null
+++ b/server/src/main/java/org/opensearch/identity/tokens/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.
+ */
+
+/** Classes for the authentication tokens in OpenSearch */
+package org.opensearch.identity.tokens;
diff --git a/server/src/main/java/org/opensearch/indices/IndicesService.java b/server/src/main/java/org/opensearch/indices/IndicesService.java
index 60df48800f921..b3843dfd114a9 100644
--- a/server/src/main/java/org/opensearch/indices/IndicesService.java
+++ b/server/src/main/java/org/opensearch/indices/IndicesService.java
@@ -82,7 +82,6 @@
 import org.opensearch.common.util.concurrent.OpenSearchExecutors;
 import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
 import org.opensearch.common.util.concurrent.OpenSearchThreadPoolExecutor;
-import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.common.util.iterable.Iterables;
 import org.opensearch.common.util.set.Sets;
 import org.opensearch.common.xcontent.LoggingDeprecationHandler;
@@ -339,122 +338,6 @@ protected void doStart() {
         threadPool.schedule(this.cacheCleaner, this.cleanInterval, ThreadPool.Names.SAME);
     }
 
-    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,
-        FileCacheCleaner fileCacheCleaner
-    ) {
-        this.settings = settings;
-        this.threadPool = threadPool;
-        this.pluginsService = pluginsService;
-        this.extensionsManager = null;
-        this.nodeEnv = nodeEnv;
-        this.xContentRegistry = xContentRegistry;
-        this.valuesSourceRegistry = valuesSourceRegistry;
-        this.shardsClosedTimeout = settings.getAsTime(INDICES_SHARDS_CLOSED_TIMEOUT, new TimeValue(1, TimeUnit.DAYS));
-        this.analysisRegistry = analysisRegistry;
-        this.indexNameExpressionResolver = indexNameExpressionResolver;
-        this.indicesRequestCache = new IndicesRequestCache(settings);
-        this.indicesQueryCache = new IndicesQueryCache(settings);
-        this.mapperRegistry = mapperRegistry;
-        this.namedWriteableRegistry = namedWriteableRegistry;
-        indexingMemoryController = new IndexingMemoryController(
-            settings,
-            threadPool,
-            // ensure we pull an iter with new shards - flatten makes a copy
-            () -> Iterables.flatten(this).iterator()
-        );
-        this.indexScopedSettings = indexScopedSettings;
-        this.circuitBreakerService = circuitBreakerService;
-        this.bigArrays = bigArrays;
-        this.scriptService = scriptService;
-        this.clusterService = clusterService;
-        this.client = client;
-        this.idFieldDataEnabled = INDICES_ID_FIELD_DATA_ENABLED_SETTING.get(clusterService.getSettings());
-        clusterService.getClusterSettings().addSettingsUpdateConsumer(INDICES_ID_FIELD_DATA_ENABLED_SETTING, this::setIdFieldDataEnabled);
-        this.indicesFieldDataCache = new IndicesFieldDataCache(settings, new IndexFieldDataCache.Listener() {
-            @Override
-            public void onRemoval(ShardId shardId, String fieldName, boolean wasEvicted, long sizeInBytes) {
-                assert sizeInBytes >= 0 : "When reducing circuit breaker, it should be adjusted with a number higher or "
-                    + "equal to 0 and not ["
-                    + sizeInBytes
-                    + "]";
-                circuitBreakerService.getBreaker(CircuitBreaker.FIELDDATA).addWithoutBreaking(-sizeInBytes);
-            }
-        });
-        this.cleanInterval = INDICES_CACHE_CLEAN_INTERVAL_SETTING.get(settings);
-        this.cacheCleaner = new CacheCleaner(indicesFieldDataCache, indicesRequestCache, logger, threadPool, this.cleanInterval);
-        this.metaStateService = metaStateService;
-        this.engineFactoryProviders = engineFactoryProviders;
-
-        this.directoryFactories = directoryFactories;
-        this.recoveryStateFactories = recoveryStateFactories;
-        this.fileCacheCleaner = fileCacheCleaner;
-        // doClose() is called when shutting down a node, yet there might still be ongoing requests
-        // that we need to wait for before closing some resources such as the caches. In order to
-        // avoid closing these resources while ongoing requests are still being processed, we use a
-        // ref count which will only close them when both this service and all index services are
-        // actually closed
-        indicesRefCount = new AbstractRefCounted("indices") {
-            @Override
-            protected void closeInternal() {
-                try {
-                    IOUtils.close(
-                        analysisRegistry,
-                        indexingMemoryController,
-                        indicesFieldDataCache,
-                        cacheCleaner,
-                        indicesRequestCache,
-                        indicesQueryCache
-                    );
-                } catch (IOException e) {
-                    throw new UncheckedIOException(e);
-                } finally {
-                    closeLatch.countDown();
-                }
-            }
-        };
-
-        final String nodeName = Objects.requireNonNull(Node.NODE_NAME_SETTING.get(settings));
-        nodeWriteDanglingIndicesInfo = WRITE_DANGLING_INDICES_INFO_SETTING.get(settings);
-        danglingIndicesThreadPoolExecutor = nodeWriteDanglingIndicesInfo
-            ? OpenSearchExecutors.newScaling(
-                nodeName + "/" + DANGLING_INDICES_UPDATE_THREAD_NAME,
-                1,
-                1,
-                0,
-                TimeUnit.MILLISECONDS,
-                daemonThreadFactory(nodeName, DANGLING_INDICES_UPDATE_THREAD_NAME),
-                threadPool.getThreadContext()
-            )
-            : null;
-
-        this.allowExpensiveQueries = ALLOW_EXPENSIVE_QUERIES.get(clusterService.getSettings());
-        clusterService.getClusterSettings().addSettingsUpdateConsumer(ALLOW_EXPENSIVE_QUERIES, this::setAllowExpensiveQueries);
-        this.remoteDirectoryFactory = remoteDirectoryFactory;
-        this.translogFactorySupplier = getTranslogFactorySupplier(repositoriesServiceSupplier, threadPool);
-    }
-
     public IndicesService(
         Settings settings,
         PluginsService pluginsService,
@@ -926,9 +809,7 @@ private synchronized IndexService createIndexService(
             indexModule.addIndexOperationListener(operationListener);
         }
         pluginsService.onIndexModule(indexModule);
-        if (FeatureFlags.isEnabled(FeatureFlags.EXTENSIONS)) {
-            extensionsManager.onIndexModule(indexModule);
-        }
+        extensionsManager.onIndexModule(indexModule);
         for (IndexEventListener listener : builtInListeners) {
             indexModule.addIndexEventListener(listener);
         }
diff --git a/server/src/main/java/org/opensearch/node/Node.java b/server/src/main/java/org/opensearch/node/Node.java
index dc4a11cf7102a..3827041a60aa3 100644
--- a/server/src/main/java/org/opensearch/node/Node.java
+++ b/server/src/main/java/org/opensearch/node/Node.java
@@ -145,6 +145,7 @@
 import org.opensearch.gateway.MetaStateService;
 import org.opensearch.gateway.PersistedClusterStateService;
 import org.opensearch.http.HttpServerTransport;
+import org.opensearch.identity.IdentityService;
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.analysis.AnalysisRegistry;
 import org.opensearch.index.engine.EngineFactory;
@@ -177,6 +178,7 @@
 import org.opensearch.plugins.ClusterPlugin;
 import org.opensearch.plugins.DiscoveryPlugin;
 import org.opensearch.plugins.EnginePlugin;
+import org.opensearch.plugins.IdentityPlugin;
 import org.opensearch.plugins.IndexStorePlugin;
 import org.opensearch.plugins.IngestPlugin;
 import org.opensearch.plugins.MapperPlugin;
@@ -454,8 +456,17 @@ protected Node(
             // Ensure to initialize Feature Flags via the settings from opensearch.yml
             FeatureFlags.initializeFeatureFlags(settings);
 
+            final List<IdentityPlugin> identityPlugins = new ArrayList<>();
+            if (FeatureFlags.isEnabled(FeatureFlags.IDENTITY)) {
+                // If identity is enabled load plugins implementing the extension point
+                logger.info("Identity on so found plugins implementing: " + pluginsService.filterPlugins(IdentityPlugin.class).toString());
+                identityPlugins.addAll(pluginsService.filterPlugins(IdentityPlugin.class));
+            }
+
+            final IdentityService identityService = new IdentityService(settings, identityPlugins);
+
             if (FeatureFlags.isEnabled(FeatureFlags.EXTENSIONS)) {
-                this.extensionsManager = new ExtensionsManager(tmpSettings, initialEnvironment.extensionDir());
+                this.extensionsManager = new ExtensionsManager(initialEnvironment.extensionDir());
             } else {
                 this.extensionsManager = new NoopExtensionsManager();
             }
@@ -693,61 +704,32 @@ protected Node(
                 repositoriesServiceReference::get
             );
 
-            final IndicesService indicesService;
-            if (FeatureFlags.isEnabled(FeatureFlags.EXTENSIONS)) {
-                indicesService = new IndicesService(
-                    settings,
-                    pluginsService,
-                    extensionsManager,
-                    nodeEnvironment,
-                    xContentRegistry,
-                    analysisModule.getAnalysisRegistry(),
-                    clusterModule.getIndexNameExpressionResolver(),
-                    indicesModule.getMapperRegistry(),
-                    namedWriteableRegistry,
-                    threadPool,
-                    settingsModule.getIndexScopedSettings(),
-                    circuitBreakerService,
-                    bigArrays,
-                    scriptService,
-                    clusterService,
-                    client,
-                    metaStateService,
-                    engineFactoryProviders,
-                    Map.copyOf(directoryFactories),
-                    searchModule.getValuesSourceRegistry(),
-                    recoveryStateFactories,
-                    remoteDirectoryFactory,
-                    repositoriesServiceReference::get,
-                    fileCacheCleaner
-                );
-            } else {
-                indicesService = new IndicesService(
-                    settings,
-                    pluginsService,
-                    nodeEnvironment,
-                    xContentRegistry,
-                    analysisModule.getAnalysisRegistry(),
-                    clusterModule.getIndexNameExpressionResolver(),
-                    indicesModule.getMapperRegistry(),
-                    namedWriteableRegistry,
-                    threadPool,
-                    settingsModule.getIndexScopedSettings(),
-                    circuitBreakerService,
-                    bigArrays,
-                    scriptService,
-                    clusterService,
-                    client,
-                    metaStateService,
-                    engineFactoryProviders,
-                    Map.copyOf(directoryFactories),
-                    searchModule.getValuesSourceRegistry(),
-                    recoveryStateFactories,
-                    remoteDirectoryFactory,
-                    repositoriesServiceReference::get,
-                    fileCacheCleaner
-                );
-            }
+            final IndicesService indicesService = new IndicesService(
+                settings,
+                pluginsService,
+                extensionsManager,
+                nodeEnvironment,
+                xContentRegistry,
+                analysisModule.getAnalysisRegistry(),
+                clusterModule.getIndexNameExpressionResolver(),
+                indicesModule.getMapperRegistry(),
+                namedWriteableRegistry,
+                threadPool,
+                settingsModule.getIndexScopedSettings(),
+                circuitBreakerService,
+                bigArrays,
+                scriptService,
+                clusterService,
+                client,
+                metaStateService,
+                engineFactoryProviders,
+                Map.copyOf(directoryFactories),
+                searchModule.getValuesSourceRegistry(),
+                recoveryStateFactories,
+                remoteDirectoryFactory,
+                repositoriesServiceReference::get,
+                fileCacheCleaner
+            );
 
             final AliasValidator aliasValidator = new AliasValidator();
 
@@ -812,7 +794,8 @@ protected Node(
                 client,
                 circuitBreakerService,
                 usageService,
-                systemIndices
+                systemIndices,
+                identityService
             );
             modules.add(actionModule);
 
@@ -863,16 +846,14 @@ protected Node(
             );
             TopNSearchTasksLogger taskConsumer = new TopNSearchTasksLogger(settings, settingsModule.getClusterSettings());
             transportService.getTaskManager().registerTaskResourceConsumer(taskConsumer);
-            if (FeatureFlags.isEnabled(FeatureFlags.EXTENSIONS)) {
-                this.extensionsManager.initializeServicesAndRestHandler(
-                    actionModule,
-                    settingsModule,
-                    transportService,
-                    clusterService,
-                    environment.settings(),
-                    client
-                );
-            }
+            this.extensionsManager.initializeServicesAndRestHandler(
+                actionModule,
+                settingsModule,
+                transportService,
+                clusterService,
+                environment.settings(),
+                client
+            );
             final GatewayMetaState gatewayMetaState = new GatewayMetaState();
             final ResponseCollectorService responseCollectorService = new ResponseCollectorService(clusterService);
             final SearchTransportService searchTransportService = new SearchTransportService(
@@ -1124,6 +1105,7 @@ protected Node(
                 b.bind(ShardLimitValidator.class).toInstance(shardLimitValidator);
                 b.bind(FsHealthService.class).toInstance(fsHealthService);
                 b.bind(SystemIndices.class).toInstance(systemIndices);
+                b.bind(IdentityService.class).toInstance(identityService);
             });
             injector = modules.createInjector();
 
@@ -1304,9 +1286,7 @@ public Node start() throws NodeValidationException {
         assert clusterService.localNode().equals(localNodeFactory.getNode())
             : "clusterService has a different local node than the factory provided";
         transportService.acceptIncomingRequests();
-        if (FeatureFlags.isEnabled(FeatureFlags.EXTENSIONS)) {
-            extensionsManager.initialize();
-        }
+        extensionsManager.initialize();
         discovery.startInitialJoin();
         final TimeValue initialStateTimeout = DiscoverySettings.INITIAL_STATE_TIMEOUT_SETTING.get(settings());
         configureNodeAndClusterIdStateListener(clusterService);
diff --git a/server/src/main/java/org/opensearch/plugins/IdentityPlugin.java b/server/src/main/java/org/opensearch/plugins/IdentityPlugin.java
new file mode 100644
index 0000000000000..4cb15f4ab3cbe
--- /dev/null
+++ b/server/src/main/java/org/opensearch/plugins/IdentityPlugin.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.plugins;
+
+import org.opensearch.identity.Subject;
+
+/**
+ * Plugin that provides identity and access control for OpenSearch
+ *
+ * @opensearch.experimental
+ */
+public interface IdentityPlugin {
+
+    /**
+     * Get the current subject
+     *
+     * Should never return null
+     * */
+    public Subject getSubject();
+}
diff --git a/server/src/main/java/org/opensearch/rest/RestController.java b/server/src/main/java/org/opensearch/rest/RestController.java
index 2554a1f376d4b..c3ef93abc35d9 100644
--- a/server/src/main/java/org/opensearch/rest/RestController.java
+++ b/server/src/main/java/org/opensearch/rest/RestController.java
@@ -47,9 +47,14 @@
 import org.opensearch.common.path.PathTrie;
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.common.xcontent.XContentType;
 import org.opensearch.common.util.io.Streams;
 import org.opensearch.http.HttpServerTransport;
+import org.opensearch.identity.IdentityService;
+import org.opensearch.identity.Subject;
+import org.opensearch.identity.tokens.AuthToken;
+import org.opensearch.identity.tokens.RestTokenExtractor;
 import org.opensearch.indices.breaker.CircuitBreakerService;
 import org.opensearch.usage.UsageService;
 
@@ -110,13 +115,15 @@ public class RestController implements HttpServerTransport.Dispatcher {
     /** Rest headers that are copied to internal requests made during a rest request. */
     private final Set<RestHeaderDefinition> headersToCopy;
     private final UsageService usageService;
+    private final IdentityService identityService;
 
     public RestController(
         Set<RestHeaderDefinition> headersToCopy,
         UnaryOperator<RestHandler> handlerWrapper,
         NodeClient client,
         CircuitBreakerService circuitBreakerService,
-        UsageService usageService
+        UsageService usageService,
+        IdentityService identityService
     ) {
         this.headersToCopy = headersToCopy;
         this.usageService = usageService;
@@ -126,6 +133,7 @@ public RestController(
         this.handlerWrapper = handlerWrapper;
         this.client = client;
         this.circuitBreakerService = circuitBreakerService;
+        this.identityService = identityService;
         registerHandlerNoWrap(
             RestRequest.Method.GET,
             "/favicon.ico",
@@ -395,6 +403,11 @@ private void tryAllHandlers(final RestRequest request, final RestChannel channel
                         return;
                     }
                 } else {
+                    if (FeatureFlags.isEnabled(FeatureFlags.IDENTITY)) {
+                        if (!handleAuthenticateUser(request, channel)) {
+                            return;
+                        }
+                    }
                     dispatchRequest(request, channel, handler);
                     return;
                 }
@@ -505,6 +518,41 @@ private void handleBadRequest(String uri, RestRequest.Method method, RestChannel
         }
     }
 
+    /**
+     * Attempts to extract auth token and login.
+     *
+     * @returns false if there was an error and the request should not continue being dispatched
+     * */
+    private boolean handleAuthenticateUser(final RestRequest request, final RestChannel channel) {
+        try {
+            final AuthToken token = RestTokenExtractor.extractToken(request);
+            // If no token was found, continue executing the request
+            if (token == null) {
+                // 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);
+        } catch (final Exception e) {
+            try {
+                final BytesRestResponse bytesRestResponse = BytesRestResponse.createSimpleErrorResponse(
+                    channel,
+                    RestStatus.UNAUTHORIZED,
+                    e.getMessage()
+                );
+                channel.sendResponse(bytesRestResponse);
+            } catch (final Exception ex) {
+                final BytesRestResponse bytesRestResponse = new BytesRestResponse(RestStatus.UNAUTHORIZED, ex.getMessage());
+                channel.sendResponse(bytesRestResponse);
+            }
+            return false;
+        }
+
+        // Authentication did not fail so return true. Authorization is handled at the action level.
+        return true;
+    }
+
     /**
      * Get the valid set of HTTP methods for a REST request.
      */
diff --git a/server/src/main/java/org/opensearch/search/SearchModule.java b/server/src/main/java/org/opensearch/search/SearchModule.java
index 30614b6eea0fa..c14f63b21fa83 100644
--- a/server/src/main/java/org/opensearch/search/SearchModule.java
+++ b/server/src/main/java/org/opensearch/search/SearchModule.java
@@ -35,7 +35,6 @@
 import org.apache.lucene.search.BooleanQuery;
 import org.opensearch.common.NamedRegistry;
 import org.opensearch.common.Nullable;
-import org.opensearch.core.ParseField;
 import org.opensearch.common.geo.GeoShapeType;
 import org.opensearch.common.geo.ShapesAvailability;
 import org.opensearch.common.io.stream.NamedWriteableRegistry;
@@ -43,8 +42,10 @@
 import org.opensearch.common.io.stream.Writeable;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.common.xcontent.ParseFieldRegistry;
+import org.opensearch.core.ParseField;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
 import org.opensearch.core.xcontent.XContentParser;
 import org.opensearch.index.query.BoolQueryBuilder;
 import org.opensearch.index.query.BoostingQueryBuilder;
@@ -255,6 +256,7 @@
 import org.opensearch.search.fetch.subphase.highlight.Highlighter;
 import org.opensearch.search.fetch.subphase.highlight.PlainHighlighter;
 import org.opensearch.search.fetch.subphase.highlight.UnifiedHighlighter;
+import org.opensearch.search.query.ConcurrentQueryPhaseSearcher;
 import org.opensearch.search.query.QueryPhase;
 import org.opensearch.search.query.QueryPhaseSearcher;
 import org.opensearch.search.rescore.QueryRescorerBuilder;
@@ -292,6 +294,7 @@
 import static java.util.Collections.unmodifiableMap;
 import static java.util.Objects.requireNonNull;
 import static org.opensearch.index.query.CommonTermsQueryBuilder.COMMON_TERMS_QUERY_DEPRECATION_MSG;
+import static org.opensearch.threadpool.ThreadPool.Names.INDEX_SEARCHER;
 
 /**
  * Sets up things that can be done at search time like queries, aggregations, and suggesters.
@@ -1252,6 +1255,9 @@ private QueryPhaseSearcher registerQueryPhaseSearcher(List<SearchPlugin> plugins
             }
         }
 
+        if (searcher == null && FeatureFlags.isEnabled(FeatureFlags.CONCURRENT_SEGMENT_SEARCH)) {
+            searcher = new ConcurrentQueryPhaseSearcher();
+        }
         return searcher;
     }
 
@@ -1270,6 +1276,9 @@ private SearchPlugin.ExecutorServiceProvider registerIndexSearcherExecutorProvid
             }
         }
 
+        if (provider == null && FeatureFlags.isEnabled(FeatureFlags.CONCURRENT_SEGMENT_SEARCH)) {
+            provider = (ThreadPool threadPool) -> threadPool.executor(INDEX_SEARCHER);
+        }
         return provider;
     }
 
@@ -1282,6 +1291,6 @@ public QueryPhase getQueryPhase() {
     }
 
     public @Nullable ExecutorService getIndexSearcherExecutor(ThreadPool pool) {
-        return (indexSearcherExecutorProvider == null) ? null : indexSearcherExecutorProvider.getExecutor(pool);
+        return (indexSearcherExecutorProvider != null) ? indexSearcherExecutorProvider.getExecutor(pool) : null;
     }
 }
diff --git a/server/src/main/java/org/opensearch/search/SearchService.java b/server/src/main/java/org/opensearch/search/SearchService.java
index cc1ee60dbb6bf..cdd30a2a8847d 100644
--- a/server/src/main/java/org/opensearch/search/SearchService.java
+++ b/server/src/main/java/org/opensearch/search/SearchService.java
@@ -69,8 +69,8 @@
 import org.opensearch.common.util.CollectionUtils;
 import org.opensearch.common.util.concurrent.ConcurrentCollections;
 import org.opensearch.common.util.concurrent.ConcurrentMapLong;
-import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
 import org.opensearch.common.util.io.IOUtils;
+import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
 import org.opensearch.index.Index;
 import org.opensearch.index.IndexNotFoundException;
 import org.opensearch.index.IndexService;
@@ -324,7 +324,6 @@ public SearchService(
             circuitBreakerService.getBreaker(CircuitBreaker.REQUEST)
         );
         this.indexSearcherExecutor = indexSearcherExecutor;
-
         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));
diff --git a/sandbox/plugins/concurrent-search/src/main/java/org/opensearch/search/query/ConcurrentQueryPhaseSearcher.java b/server/src/main/java/org/opensearch/search/query/ConcurrentQueryPhaseSearcher.java
similarity index 100%
rename from sandbox/plugins/concurrent-search/src/main/java/org/opensearch/search/query/ConcurrentQueryPhaseSearcher.java
rename to server/src/main/java/org/opensearch/search/query/ConcurrentQueryPhaseSearcher.java
index 65f339838a40b..1b4e8c5e3e56f 100644
--- a/sandbox/plugins/concurrent-search/src/main/java/org/opensearch/search/query/ConcurrentQueryPhaseSearcher.java
+++ b/server/src/main/java/org/opensearch/search/query/ConcurrentQueryPhaseSearcher.java
@@ -8,11 +8,6 @@
 
 package org.opensearch.search.query;
 
-import static org.opensearch.search.query.TopDocsCollectorContext.createTopDocsCollectorContext;
-
-import java.io.IOException;
-import java.util.LinkedList;
-
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.lucene.search.Collector;
@@ -24,6 +19,11 @@
 import org.opensearch.search.query.QueryPhase.DefaultQueryPhaseSearcher;
 import org.opensearch.search.query.QueryPhase.TimeExceededException;
 
+import java.io.IOException;
+import java.util.LinkedList;
+
+import static org.opensearch.search.query.TopDocsCollectorContext.createTopDocsCollectorContext;
+
 /**
  * The implementation of the {@link QueryPhaseSearcher} which attempts to use concurrent
  * search of Apache Lucene segments if it has been enabled.
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 405efeb37cb70..4e9bc25df3a1a 100644
--- a/server/src/main/java/org/opensearch/search/query/QueryPhase.java
+++ b/server/src/main/java/org/opensearch/search/query/QueryPhase.java
@@ -36,7 +36,6 @@
 import org.apache.logging.log4j.Logger;
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.LeafReaderContext;
-import org.opensearch.lucene.queries.SearchAfterSortedDocQuery;
 import org.apache.lucene.search.BooleanClause;
 import org.apache.lucene.search.BooleanQuery;
 import org.apache.lucene.search.Collector;
@@ -51,6 +50,7 @@
 import org.opensearch.common.lucene.Lucene;
 import org.opensearch.common.lucene.search.TopDocsAndMaxScore;
 import org.opensearch.common.util.concurrent.EWMATrackingThreadPoolExecutor;
+import org.opensearch.lucene.queries.SearchAfterSortedDocQuery;
 import org.opensearch.search.DocValueFormat;
 import org.opensearch.search.SearchContextSourcePrinter;
 import org.opensearch.search.SearchService;
diff --git a/server/src/main/java/org/opensearch/threadpool/ThreadPool.java b/server/src/main/java/org/opensearch/threadpool/ThreadPool.java
index 31d43acadb611..49019ab4ad594 100644
--- a/server/src/main/java/org/opensearch/threadpool/ThreadPool.java
+++ b/server/src/main/java/org/opensearch/threadpool/ThreadPool.java
@@ -44,6 +44,7 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.SizeValue;
 import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.common.util.concurrent.OpenSearchExecutors;
 import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
 import org.opensearch.common.util.concurrent.OpenSearchThreadPoolExecutor;
@@ -112,6 +113,7 @@ public static class Names {
         public static final String TRANSLOG_SYNC = "translog_sync";
         public static final String REMOTE_PURGE = "remote_purge";
         public static final String REMOTE_REFRESH = "remote_refresh";
+        public static final String INDEX_SEARCHER = "index_searcher";
     }
 
     /**
@@ -180,6 +182,9 @@ public static ThreadPoolType fromType(String type) {
         map.put(Names.TRANSLOG_SYNC, ThreadPoolType.FIXED);
         map.put(Names.REMOTE_PURGE, ThreadPoolType.SCALING);
         map.put(Names.REMOTE_REFRESH, ThreadPoolType.SCALING);
+        if (FeatureFlags.isEnabled(FeatureFlags.CONCURRENT_SEGMENT_SEARCH)) {
+            map.put(Names.INDEX_SEARCHER, ThreadPoolType.FIXED);
+        }
         THREAD_POOL_TYPES = Collections.unmodifiableMap(map);
     }
 
@@ -262,6 +267,9 @@ public ThreadPool(
             Names.REMOTE_REFRESH,
             new ScalingExecutorBuilder(Names.REMOTE_REFRESH, 1, allocatedProcessors * 4, TimeValue.timeValueMinutes(5))
         );
+        if (FeatureFlags.isEnabled(FeatureFlags.CONCURRENT_SEGMENT_SEARCH)) {
+            builders.put(Names.INDEX_SEARCHER, new FixedExecutorBuilder(settings, Names.INDEX_SEARCHER, allocatedProcessors, 1000, false));
+        }
 
         for (final ExecutorBuilder<?> builder : customBuilders) {
             if (builders.containsKey(builder.name())) {
diff --git a/server/src/main/proto/extensions/ExtensionIdentityProto.proto b/server/src/main/proto/extensions/ExtensionIdentityProto.proto
new file mode 100644
index 0000000000000..16941c23b6794
--- /dev/null
+++ b/server/src/main/proto/extensions/ExtensionIdentityProto.proto
@@ -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.
+ *
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+syntax = "proto3";
+package org.opensearch.extensions.proto;
+
+option java_outer_classname = "ExtensionIdentityProto";
+
+message ExtensionIdentity {
+  string uniqueId = 1;
+}
diff --git a/server/src/main/proto/extensions/ExtensionRequestProto.proto b/server/src/main/proto/extensions/ExtensionRequestProto.proto
index a49e413d37ca9..9526e4145b281 100644
--- a/server/src/main/proto/extensions/ExtensionRequestProto.proto
+++ b/server/src/main/proto/extensions/ExtensionRequestProto.proto
@@ -12,6 +12,7 @@
 syntax = "proto3";
 package org.opensearch.extensions.proto;
 
+import "extensions/ExtensionIdentityProto.proto";
 option java_outer_classname = "ExtensionRequestProto";
 
 enum RequestType {
@@ -27,6 +28,6 @@ enum RequestType {
 }
 
 message ExtensionRequest {
-  RequestType requestType = 1;
-  string uniqueId = 2;
+  ExtensionIdentity identity = 1;
+  RequestType requestType = 2;
 }
diff --git a/server/src/main/proto/extensions/RegisterRestActionsProto.proto b/server/src/main/proto/extensions/RegisterRestActionsProto.proto
new file mode 100644
index 0000000000000..fa5599b118a8b
--- /dev/null
+++ b/server/src/main/proto/extensions/RegisterRestActionsProto.proto
@@ -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.
+ *
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+syntax = "proto3";
+package org.opensearch.extensions.proto;
+
+import "extensions/ExtensionIdentityProto.proto";
+option java_outer_classname = "RegisterRestActionsProto";
+
+message RegisterRestActions {
+  ExtensionIdentity identity = 1;
+  repeated string restActions = 2;
+  repeated string deprecatedRestActions = 3;
+}
diff --git a/server/src/main/proto/extensions/RegisterTransportActionsProto.proto b/server/src/main/proto/extensions/RegisterTransportActionsProto.proto
new file mode 100644
index 0000000000000..a6ce252cedf88
--- /dev/null
+++ b/server/src/main/proto/extensions/RegisterTransportActionsProto.proto
@@ -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.
+ */
+
+syntax = "proto3";
+package org.opensearch.extensions.proto;
+
+import "extensions/ExtensionIdentityProto.proto";
+option java_outer_classname = "RegisterTransportActionsProto";
+
+message RegisterTransportActions {
+  ExtensionIdentity identity = 1;
+  repeated string transportActions = 2;
+}
diff --git a/server/src/test/java/org/opensearch/action/ActionModuleTests.java b/server/src/test/java/org/opensearch/action/ActionModuleTests.java
index 94ebf0fcf8816..41375dc005ef3 100644
--- a/server/src/test/java/org/opensearch/action/ActionModuleTests.java
+++ b/server/src/test/java/org/opensearch/action/ActionModuleTests.java
@@ -32,6 +32,7 @@
 
 package org.opensearch.action;
 
+import java.util.ArrayList;
 import org.opensearch.action.ActionModule.DynamicActionRegistry;
 import org.opensearch.action.main.MainAction;
 import org.opensearch.action.main.TransportMainAction;
@@ -50,6 +51,7 @@
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.extensions.action.ExtensionAction;
 import org.opensearch.extensions.action.ExtensionTransportAction;
+import org.opensearch.identity.IdentityService;
 import org.opensearch.plugins.ActionPlugin;
 import org.opensearch.plugins.ActionPlugin.ActionHandler;
 
@@ -143,7 +145,8 @@ public void testSetupRestHandlerContainsKnownBuiltin() {
             null,
             null,
             usageService,
-            null
+            null,
+            new IdentityService(Settings.EMPTY, new ArrayList<>())
         );
         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
@@ -199,6 +202,7 @@ public String getName() {
                 null,
                 null,
                 usageService,
+                null,
                 null
             );
             Exception e = expectThrows(IllegalArgumentException.class, () -> actionModule.initRestHandlers(null));
@@ -248,6 +252,7 @@ public List<RestHandler> getRestHandlers(
                 null,
                 null,
                 usageService,
+                null,
                 null
             );
             actionModule.initRestHandlers(null);
diff --git a/server/src/test/java/org/opensearch/bootstrap/IdentityPluginTests.java b/server/src/test/java/org/opensearch/bootstrap/IdentityPluginTests.java
new file mode 100644
index 0000000000000..5595fdd564d01
--- /dev/null
+++ b/server/src/test/java/org/opensearch/bootstrap/IdentityPluginTests.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.bootstrap;
+
+import java.util.List;
+import org.opensearch.OpenSearchException;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.identity.IdentityService;
+import org.opensearch.identity.noop.NoopIdentityPlugin;
+import org.opensearch.plugins.IdentityPlugin;
+import org.opensearch.test.OpenSearchTestCase;
+
+public class IdentityPluginTests extends OpenSearchTestCase {
+
+    public void testSingleIdentityPluginSucceeds() {
+        IdentityPlugin identityPlugin1 = new NoopIdentityPlugin();
+        List<IdentityPlugin> pluginList = List.of(identityPlugin1);
+        IdentityService identityService = new IdentityService(Settings.EMPTY, pluginList);
+        assertTrue(identityService.getSubject().getPrincipal().getName().equalsIgnoreCase("Unauthenticated"));
+    }
+
+    public void testMultipleIdentityPluginsFail() {
+        IdentityPlugin identityPlugin1 = new NoopIdentityPlugin();
+        IdentityPlugin identityPlugin2 = new NoopIdentityPlugin();
+        IdentityPlugin identityPlugin3 = new NoopIdentityPlugin();
+        List<IdentityPlugin> pluginList = List.of(identityPlugin1, identityPlugin2, identityPlugin3);
+        Exception ex = assertThrows(OpenSearchException.class, () -> new IdentityService(Settings.EMPTY, pluginList));
+        assert (ex.getMessage().contains("Multiple identity plugins are not supported,"));
+    }
+}
diff --git a/server/src/test/java/org/opensearch/extensions/ExtensionsManagerTests.java b/server/src/test/java/org/opensearch/extensions/ExtensionsManagerTests.java
index 9d60e8ad31873..0a9fd2e6b94fe 100644
--- a/server/src/test/java/org/opensearch/extensions/ExtensionsManagerTests.java
+++ b/server/src/test/java/org/opensearch/extensions/ExtensionsManagerTests.java
@@ -70,6 +70,7 @@
 import org.opensearch.extensions.proto.ExtensionRequestProto;
 import org.opensearch.extensions.rest.RegisterRestActionsRequest;
 import org.opensearch.extensions.settings.RegisterCustomSettingsRequest;
+import org.opensearch.identity.IdentityService;
 import org.opensearch.index.IndexModule;
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.analysis.AnalysisRegistry;
@@ -166,7 +167,8 @@ public void setup() throws Exception {
             null,
             new NodeClient(Settings.EMPTY, threadPool),
             new NoneCircuitBreakerService(),
-            new UsageService()
+            new UsageService(),
+            new IdentityService(Settings.EMPTY, List.of())
         );
         when(actionModule.getRestController()).thenReturn(restController);
         settingsModule = new SettingsModule(Settings.EMPTY, emptyList(), emptyList(), emptySet());
@@ -199,7 +201,7 @@ public void tearDown() throws Exception {
     public void testDiscover() throws Exception {
         Files.write(extensionDir.resolve("extensions.yml"), extensionsYmlLines, StandardCharsets.UTF_8);
 
-        ExtensionsManager extensionsManager = new ExtensionsManager(settings, extensionDir);
+        ExtensionsManager extensionsManager = new ExtensionsManager(extensionDir);
 
         List<DiscoveryExtensionNode> expectedExtensions = new ArrayList<DiscoveryExtensionNode>();
 
@@ -251,7 +253,7 @@ public void testNonUniqueExtensionsDiscovery() throws Exception {
             .collect(Collectors.toList());
         Files.write(emptyExtensionDir.resolve("extensions.yml"), nonUniqueYmlLines, StandardCharsets.UTF_8);
 
-        ExtensionsManager extensionsManager = new ExtensionsManager(settings, emptyExtensionDir);
+        ExtensionsManager extensionsManager = new ExtensionsManager(emptyExtensionDir);
 
         List<DiscoveryExtensionNode> expectedExtensions = new ArrayList<DiscoveryExtensionNode>();
 
@@ -300,7 +302,7 @@ public void testMissingRequiredFieldsInExtensionDiscovery() throws Exception {
                 )
             );
 
-            extensionsManager = new ExtensionsManager(settings, emptyExtensionDir);
+            extensionsManager = new ExtensionsManager(emptyExtensionDir);
 
             mockLogAppender.assertAllExpectationsMatched();
         }
@@ -385,7 +387,7 @@ public void testNonAccessibleDirectory() throws Exception {
         AccessControlException e = expectThrows(
 
             AccessControlException.class,
-            () -> new ExtensionsManager(settings, PathUtils.get(""))
+            () -> new ExtensionsManager(PathUtils.get(""))
         );
         assertEquals("access denied (\"java.io.FilePermission\" \"\" \"read\")", e.getMessage());
     }
@@ -404,7 +406,7 @@ public void testNoExtensionsFile() throws Exception {
                 )
             );
 
-            new ExtensionsManager(settings, extensionDir);
+            new ExtensionsManager(extensionDir);
 
             mockLogAppender.assertAllExpectationsMatched();
         }
@@ -418,12 +420,12 @@ public void testEmptyExtensionsFile() throws Exception {
 
         Settings settings = Settings.builder().build();
 
-        expectThrows(IOException.class, () -> new ExtensionsManager(settings, emptyExtensionDir));
+        expectThrows(IOException.class, () -> new ExtensionsManager(emptyExtensionDir));
     }
 
     public void testInitialize() throws Exception {
         Files.write(extensionDir.resolve("extensions.yml"), extensionsYmlLines, StandardCharsets.UTF_8);
-        ExtensionsManager extensionsManager = new ExtensionsManager(settings, extensionDir);
+        ExtensionsManager extensionsManager = new ExtensionsManager(extensionDir);
 
         initialize(extensionsManager);
 
@@ -466,7 +468,7 @@ public void testInitialize() throws Exception {
     public void testHandleRegisterRestActionsRequest() throws Exception {
         Files.write(extensionDir.resolve("extensions.yml"), extensionsYmlLines, StandardCharsets.UTF_8);
 
-        ExtensionsManager extensionsManager = new ExtensionsManager(settings, extensionDir);
+        ExtensionsManager extensionsManager = new ExtensionsManager(extensionDir);
         initialize(extensionsManager);
 
         String uniqueIdStr = "uniqueid1";
@@ -481,7 +483,7 @@ public void testHandleRegisterRestActionsRequest() throws Exception {
 
     public void testHandleRegisterSettingsRequest() throws Exception {
         Files.write(extensionDir.resolve("extensions.yml"), extensionsYmlLines, StandardCharsets.UTF_8);
-        ExtensionsManager extensionsManager = new ExtensionsManager(settings, extensionDir);
+        ExtensionsManager extensionsManager = new ExtensionsManager(extensionDir);
         initialize(extensionsManager);
 
         String uniqueIdStr = "uniqueid1";
@@ -497,7 +499,7 @@ public void testHandleRegisterSettingsRequest() throws Exception {
     }
 
     public void testHandleRegisterRestActionsRequestWithInvalidMethod() throws Exception {
-        ExtensionsManager extensionsManager = new ExtensionsManager(settings, extensionDir);
+        ExtensionsManager extensionsManager = new ExtensionsManager(extensionDir);
         initialize(extensionsManager);
 
         String uniqueIdStr = "uniqueid1";
@@ -511,7 +513,7 @@ public void testHandleRegisterRestActionsRequestWithInvalidMethod() throws Excep
     }
 
     public void testHandleRegisterRestActionsRequestWithInvalidDeprecatedMethod() throws Exception {
-        ExtensionsManager extensionsManager = new ExtensionsManager(settings, extensionDir);
+        ExtensionsManager extensionsManager = new ExtensionsManager(extensionDir);
         initialize(extensionsManager);
 
         String uniqueIdStr = "uniqueid1";
@@ -525,7 +527,7 @@ public void testHandleRegisterRestActionsRequestWithInvalidDeprecatedMethod() th
     }
 
     public void testHandleRegisterRestActionsRequestWithInvalidUri() throws Exception {
-        ExtensionsManager extensionsManager = new ExtensionsManager(settings, extensionDir);
+        ExtensionsManager extensionsManager = new ExtensionsManager(extensionDir);
         initialize(extensionsManager);
         String uniqueIdStr = "uniqueid1";
         List<String> actionsList = List.of("GET", "PUT /bar", "POST /baz");
@@ -538,7 +540,7 @@ public void testHandleRegisterRestActionsRequestWithInvalidUri() throws Exceptio
     }
 
     public void testHandleRegisterRestActionsRequestWithInvalidDeprecatedUri() throws Exception {
-        ExtensionsManager extensionsManager = new ExtensionsManager(settings, extensionDir);
+        ExtensionsManager extensionsManager = new ExtensionsManager(extensionDir);
         initialize(extensionsManager);
         String uniqueIdStr = "uniqueid1";
         List<String> actionsList = List.of("GET /foo", "PUT /bar", "POST /baz");
@@ -551,7 +553,7 @@ public void testHandleRegisterRestActionsRequestWithInvalidDeprecatedUri() throw
     }
 
     public void testHandleExtensionRequest() throws Exception {
-        ExtensionsManager extensionsManager = new ExtensionsManager(settings, extensionDir);
+        ExtensionsManager extensionsManager = new ExtensionsManager(extensionDir);
         initialize(extensionsManager);
 
         ExtensionRequest clusterStateRequest = new ExtensionRequest(ExtensionRequestProto.RequestType.REQUEST_EXTENSION_CLUSTER_STATE);
@@ -707,7 +709,7 @@ public void testEnvironmentSettingsDefaultValue() throws Exception {
     public void testAddSettingsUpdateConsumerRequest() throws Exception {
         Path extensionDir = createTempDir();
         Files.write(extensionDir.resolve("extensions.yml"), extensionsYmlLines, StandardCharsets.UTF_8);
-        ExtensionsManager extensionsManager = new ExtensionsManager(settings, extensionDir);
+        ExtensionsManager extensionsManager = new ExtensionsManager(extensionDir);
         initialize(extensionsManager);
 
         List<Setting<?>> componentSettings = List.of(
@@ -754,7 +756,7 @@ public void testHandleAddSettingsUpdateConsumerRequest() throws Exception {
 
         Path extensionDir = createTempDir();
         Files.write(extensionDir.resolve("extensions.yml"), extensionsYmlLines, StandardCharsets.UTF_8);
-        ExtensionsManager extensionsManager = new ExtensionsManager(settings, extensionDir);
+        ExtensionsManager extensionsManager = new ExtensionsManager(extensionDir);
         initialize(extensionsManager);
 
         List<Setting<?>> componentSettings = List.of(
@@ -776,7 +778,7 @@ public void testHandleAddSettingsUpdateConsumerRequest() throws Exception {
     public void testUpdateSettingsRequest() throws Exception {
         Path extensionDir = createTempDir();
         Files.write(extensionDir.resolve("extensions.yml"), extensionsYmlLines, StandardCharsets.UTF_8);
-        ExtensionsManager extensionsManager = new ExtensionsManager(settings, extensionDir);
+        ExtensionsManager extensionsManager = new ExtensionsManager(extensionDir);
         initialize(extensionsManager);
 
         Setting<?> componentSetting = Setting.boolSetting("falseSetting", false, Property.Dynamic);
@@ -805,7 +807,7 @@ public void testUpdateSettingsRequest() throws Exception {
 
     public void testRegisterHandler() throws Exception {
 
-        ExtensionsManager extensionsManager = new ExtensionsManager(settings, extensionDir);
+        ExtensionsManager extensionsManager = new ExtensionsManager(extensionDir);
 
         TransportService mockTransportService = spy(
             new TransportService(
@@ -832,7 +834,7 @@ public void testRegisterHandler() throws Exception {
 
     public void testOnIndexModule() throws Exception {
         Files.write(extensionDir.resolve("extensions.yml"), extensionsYmlLines, StandardCharsets.UTF_8);
-        ExtensionsManager extensionsManager = new ExtensionsManager(settings, extensionDir);
+        ExtensionsManager extensionsManager = new ExtensionsManager(extensionDir);
         initialize(extensionsManager);
 
         Environment environment = TestEnvironment.newEnvironment(settings);
@@ -889,7 +891,7 @@ public void testIncompatibleExtensionRegistration() throws IOException, IllegalA
             );
 
             Files.write(extensionDir.resolve("extensions.yml"), incompatibleExtension, StandardCharsets.UTF_8);
-            ExtensionsManager extensionsManager = new ExtensionsManager(settings, extensionDir);
+            ExtensionsManager extensionsManager = new ExtensionsManager(extensionDir);
             assertEquals(0, extensionsManager.getExtensionIdMap().values().size());
             mockLogAppender.assertAllExpectationsMatched();
         }
diff --git a/server/src/test/java/org/opensearch/extensions/RegisterTransportActionsRequestTests.java b/server/src/test/java/org/opensearch/extensions/action/RegisterTransportActionsRequestTests.java
similarity index 53%
rename from server/src/test/java/org/opensearch/extensions/RegisterTransportActionsRequestTests.java
rename to server/src/test/java/org/opensearch/extensions/action/RegisterTransportActionsRequestTests.java
index e819fcd893367..fe3c0dc8dd73d 100644
--- a/server/src/test/java/org/opensearch/extensions/RegisterTransportActionsRequestTests.java
+++ b/server/src/test/java/org/opensearch/extensions/action/RegisterTransportActionsRequestTests.java
@@ -6,15 +6,15 @@
  * compatible open source license.
  */
 
-package org.opensearch.extensions;
+package org.opensearch.extensions.action;
 
 import org.junit.Before;
 import org.opensearch.common.io.stream.BytesStreamOutput;
 import org.opensearch.common.io.stream.StreamInput;
-import org.opensearch.extensions.action.RegisterTransportActionsRequest;
 import org.opensearch.test.OpenSearchTestCase;
 
 import java.io.IOException;
+import java.util.List;
 import java.util.Set;
 
 public class RegisterTransportActionsRequestTests extends OpenSearchTestCase {
@@ -37,6 +37,32 @@ public void testRegisterTransportActionsRequest() throws IOException {
     }
 
     public void testToString() {
-        assertEquals(originalRequest.toString(), "TransportActionsRequest{uniqueId=extension-uniqueId, actions=[testAction]}");
+        logger.info(originalRequest.toString());
+        assertEquals(
+            originalRequest.toString(),
+            "TransportActionsRequest{Identity=uniqueId: \"extension-uniqueId\"\n, actions=[testAction]}"
+        );
+    }
+
+    public void testNoIdentityRegisterTransportActionsRequest() {
+        String uniqueId = null;
+        // Expect exception as Extension Identity(uniqueId) is null
+        expectThrows(NullPointerException.class, () -> new RegisterTransportActionsRequest(uniqueId, Set.of()));
+    }
+
+    public void testNoTransportActionsRequest() {
+        String uniqueId = "extension-1234";
+        Set<String> expectedActions = null;
+        // Expect exception as paths are null
+        expectThrows(NullPointerException.class, () -> new RegisterTransportActionsRequest(uniqueId, expectedActions));
+    }
+
+    public void testEmptyTransportActionsRequest() {
+        String uniqueId = "extension-1234";
+        Set<String> expectedActions = Set.of();
+        RegisterTransportActionsRequest request = new RegisterTransportActionsRequest(uniqueId, expectedActions);
+
+        assertEquals(uniqueId, request.getUniqueId());
+        assertEquals(List.of(), request.getTransportActions());
     }
 }
diff --git a/server/src/test/java/org/opensearch/extensions/rest/RegisterRestActionsTests.java b/server/src/test/java/org/opensearch/extensions/rest/RegisterRestActionsTests.java
index 316d5b0b343ee..414d0bc3eadf1 100644
--- a/server/src/test/java/org/opensearch/extensions/rest/RegisterRestActionsTests.java
+++ b/server/src/test/java/org/opensearch/extensions/rest/RegisterRestActionsTests.java
@@ -47,4 +47,35 @@ public void testRegisterRestActionsRequest() throws Exception {
             }
         }
     }
+
+    public void testNoIdentityRestActionsRequest() {
+        String uniqueId = null;
+        List<String> expected = List.of("GET /foo", "PUT /bar", "POST /baz");
+        List<String> expectedDeprecated = List.of("GET /deprecated/foo", "It's deprecated");
+        // Expect exception as Extension Identity(uniqueId) is null
+        expectThrows(NullPointerException.class, () -> new RegisterRestActionsRequest(uniqueId, expected, expectedDeprecated));
+    }
+
+    public void testNoRestActionsRequest() {
+        String uniqueId = "extension-1234";
+        List<String> expected = null;
+        List<String> expectedDeprecated = null;
+        // Expect exception as paths are null
+        expectThrows(NullPointerException.class, () -> new RegisterRestActionsRequest(uniqueId, expected, expectedDeprecated));
+    }
+
+    public void testEmptyRestActionsRequest() {
+        String uniqueId = "extension-1234";
+        List<String> expected = List.of();
+        List<String> expectedDeprecated = List.of();
+        RegisterRestActionsRequest request = new RegisterRestActionsRequest(uniqueId, expected, expectedDeprecated);
+
+        assertEquals(uniqueId, request.getUniqueId());
+        assertEquals(List.of(), request.getRestActions());
+        assertEquals(List.of(), request.getDeprecatedRestActions());
+        assertEquals(
+            "RestActionsRequest{Identity=uniqueId: \"extension-1234\"\n" + ", restActions=[], deprecatedRestActions=[]}",
+            request.toString()
+        );
+    }
 }
diff --git a/server/src/test/java/org/opensearch/rest/RestControllerTests.java b/server/src/test/java/org/opensearch/rest/RestControllerTests.java
index ace7762989411..489419fc24526 100644
--- a/server/src/test/java/org/opensearch/rest/RestControllerTests.java
+++ b/server/src/test/java/org/opensearch/rest/RestControllerTests.java
@@ -52,6 +52,7 @@
 import org.opensearch.http.HttpResponse;
 import org.opensearch.http.HttpServerTransport;
 import org.opensearch.http.HttpStats;
+import org.opensearch.identity.IdentityService;
 import org.opensearch.indices.breaker.HierarchyCircuitBreakerService;
 import org.opensearch.rest.action.admin.indices.RestCreateIndexAction;
 import org.opensearch.test.OpenSearchTestCase;
@@ -92,6 +93,7 @@ public class RestControllerTests extends OpenSearchTestCase {
     private RestController restController;
     private HierarchyCircuitBreakerService circuitBreakerService;
     private UsageService usageService;
+    private IdentityService identityService;
     private NodeClient client;
 
     @Before
@@ -109,9 +111,11 @@ 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());
+
         HttpServerTransport httpServerTransport = new TestHttpServerTransport();
         client = new NoOpNodeClient(this.getTestName());
-        restController = new RestController(Collections.emptySet(), null, client, circuitBreakerService, usageService);
+        restController = new RestController(Collections.emptySet(), null, client, circuitBreakerService, usageService, identityService);
         restController.registerHandler(
             RestRequest.Method.GET,
             "/",
@@ -136,7 +140,7 @@ public void testApplyRelevantHeaders() throws Exception {
         Set<RestHeaderDefinition> headers = new HashSet<>(
             Arrays.asList(new RestHeaderDefinition("header.1", true), new RestHeaderDefinition("header.2", true))
         );
-        final RestController restController = new RestController(headers, null, null, circuitBreakerService, usageService);
+        final RestController restController = new RestController(headers, null, null, circuitBreakerService, usageService, identityService);
         Map<String, List<String>> restHeaders = new HashMap<>();
         restHeaders.put("header.1", Collections.singletonList("true"));
         restHeaders.put("header.2", Collections.singletonList("true"));
@@ -172,7 +176,7 @@ public void testRequestWithDisallowedMultiValuedHeader() {
         Set<RestHeaderDefinition> headers = new HashSet<>(
             Arrays.asList(new RestHeaderDefinition("header.1", true), new RestHeaderDefinition("header.2", false))
         );
-        final RestController restController = new RestController(headers, null, null, circuitBreakerService, usageService);
+        final RestController restController = new RestController(headers, null, null, circuitBreakerService, usageService, identityService);
         Map<String, List<String>> restHeaders = new HashMap<>();
         restHeaders.put("header.1", Collections.singletonList("boo"));
         restHeaders.put("header.2", Arrays.asList("foo", "bar"));
@@ -187,7 +191,14 @@ public void testRequestWithDisallowedMultiValuedHeaderButSameValues() {
         Set<RestHeaderDefinition> headers = new HashSet<>(
             Arrays.asList(new RestHeaderDefinition("header.1", true), new RestHeaderDefinition("header.2", false))
         );
-        final RestController restController = new RestController(headers, null, client, circuitBreakerService, usageService);
+        final RestController restController = new RestController(
+            headers,
+            null,
+            client,
+            circuitBreakerService,
+            usageService,
+            identityService
+        );
         Map<String, List<String>> restHeaders = new HashMap<>();
         restHeaders.put("header.1", Collections.singletonList("boo"));
         restHeaders.put("header.2", Arrays.asList("foo", "foo"));
@@ -248,7 +259,7 @@ public void testRegisterWithDeprecatedHandler() {
     }
 
     public void testRegisterSecondMethodWithDifferentNamedWildcard() {
-        final RestController restController = new RestController(null, null, null, circuitBreakerService, usageService);
+        final RestController restController = new RestController(null, null, null, circuitBreakerService, usageService, identityService);
 
         RestRequest.Method firstMethod = randomFrom(RestRequest.Method.values());
         RestRequest.Method secondMethod = randomFrom(
@@ -276,7 +287,7 @@ public void testRestHandlerWrapper() throws Exception {
         final RestController restController = new RestController(Collections.emptySet(), h -> {
             assertSame(handler, h);
             return (RestRequest request, RestChannel channel, NodeClient client) -> wrapperCalled.set(true);
-        }, client, circuitBreakerService, usageService);
+        }, client, circuitBreakerService, usageService, identityService);
         restController.registerHandler(RestRequest.Method.GET, "/wrapped", handler);
         RestRequest request = testRestRequest("/wrapped", "{}", XContentType.JSON);
         AssertingChannel channel = new AssertingChannel(request, true, RestStatus.BAD_REQUEST);
@@ -339,7 +350,7 @@ public void testDispatchRequiresContentTypeForRequestsWithContent() {
         String content = randomAlphaOfLength((int) Math.round(BREAKER_LIMIT.getBytes() / inFlightRequestsBreaker.getOverhead()));
         RestRequest request = testRestRequest("/", content, null);
         AssertingChannel channel = new AssertingChannel(request, true, RestStatus.NOT_ACCEPTABLE);
-        restController = new RestController(Collections.emptySet(), null, null, circuitBreakerService, usageService);
+        restController = new RestController(Collections.emptySet(), null, null, circuitBreakerService, usageService, identityService);
         restController.registerHandler(
             RestRequest.Method.GET,
             "/",
diff --git a/server/src/test/java/org/opensearch/rest/RestHttpResponseHeadersTests.java b/server/src/test/java/org/opensearch/rest/RestHttpResponseHeadersTests.java
index 2ac2b3bb5a964..c1f5cd6ddf8bd 100644
--- a/server/src/test/java/org/opensearch/rest/RestHttpResponseHeadersTests.java
+++ b/server/src/test/java/org/opensearch/rest/RestHttpResponseHeadersTests.java
@@ -37,6 +37,7 @@
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.identity.IdentityService;
 import org.opensearch.indices.breaker.CircuitBreakerService;
 import org.opensearch.indices.breaker.HierarchyCircuitBreakerService;
 import org.opensearch.test.OpenSearchTestCase;
@@ -104,7 +105,15 @@ public void testUnsupportedMethodResponseHttpHeader() throws Exception {
 
         final Settings settings = Settings.EMPTY;
         UsageService usageService = new UsageService();
-        RestController restController = new RestController(Collections.emptySet(), null, null, circuitBreakerService, usageService);
+        final IdentityService identityService = new IdentityService(settings, List.of());
+        RestController restController = new RestController(
+            Collections.emptySet(),
+            null,
+            null,
+            circuitBreakerService,
+            usageService,
+            identityService
+        );
 
         // A basic RestHandler handles requests to the endpoint
         RestHandler restHandler = new RestHandler() {
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 6971aa866ccb1..e14b003e7ccad 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
@@ -31,6 +31,7 @@
 
 package org.opensearch.rest.action.admin.indices;
 
+import java.util.List;
 import org.opensearch.action.ActionListener;
 import org.opensearch.action.ActionRequest;
 import org.opensearch.action.ActionType;
@@ -43,6 +44,7 @@
 import org.opensearch.common.io.stream.NamedWriteableRegistry;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.xcontent.XContentType;
+import org.opensearch.identity.IdentityService;
 import org.opensearch.indices.breaker.NoneCircuitBreakerService;
 import org.opensearch.rest.RestController;
 import org.opensearch.rest.RestRequest;
@@ -73,7 +75,15 @@ public class RestValidateQueryActionTests extends AbstractSearchTestCase {
     private static NodeClient client = new NodeClient(Settings.EMPTY, threadPool);
 
     private static UsageService usageService = new UsageService();
-    private static RestController controller = new RestController(emptySet(), null, client, new NoneCircuitBreakerService(), usageService);
+    private static IdentityService identityService = new IdentityService(Settings.EMPTY, List.of());
+    private static RestController controller = new RestController(
+        emptySet(),
+        null,
+        client,
+        new NoneCircuitBreakerService(),
+        usageService,
+        identityService
+    );
     private static RestValidateQueryAction action = new RestValidateQueryAction();
 
     /**
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 da2a70514a716..81c6612875e46 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
@@ -32,6 +32,7 @@
 
 package org.opensearch.search.profile.query;
 
+import com.carrotsearch.randomizedtesting.annotations.ParametersFactory;
 import org.apache.lucene.document.Document;
 import org.apache.lucene.document.Field.Store;
 import org.apache.lucene.document.StringField;
@@ -64,19 +65,34 @@
 import org.opensearch.test.OpenSearchTestCase;
 import org.junit.After;
 import org.junit.Before;
+import org.opensearch.threadpool.ThreadPool;
 
 import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
 
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.greaterThan;
 
 public class QueryProfilerTests extends OpenSearchTestCase {
-
     private Directory dir;
     private IndexReader reader;
     private ContextIndexSearcher searcher;
+    private ExecutorService executor;
+
+    @ParametersFactory
+    public static Collection<Object[]> concurrency() {
+        return Arrays.asList(new Integer[] { 0 }, new Integer[] { 5 });
+    }
+
+    public QueryProfilerTests(int concurrency) {
+        this.executor = (concurrency > 0) ? Executors.newFixedThreadPool(concurrency) : null;
+    }
 
     @Before
     public void setUp() throws Exception {
@@ -102,7 +118,7 @@ public void setUp() throws Exception {
             IndexSearcher.getDefaultQueryCache(),
             ALWAYS_CACHE_POLICY,
             true,
-            null
+            executor
         );
     }
 
@@ -116,6 +132,10 @@ public void tearDown() throws Exception {
         assertThat(cache.getTotalCount(), equalTo(cache.getMissCount()));
         assertThat(cache.getCacheSize(), equalTo(0L));
 
+        if (executor != null) {
+            ThreadPool.terminate(executor, 10, TimeUnit.SECONDS);
+        }
+
         IOUtils.close(reader, dir);
         dir = null;
         reader = null;
@@ -123,7 +143,7 @@ public void tearDown() throws Exception {
     }
 
     public void testBasic() throws IOException {
-        QueryProfiler profiler = new QueryProfiler(false);
+        QueryProfiler profiler = new QueryProfiler(executor != null);
         searcher.setProfiler(profiler);
         Query query = new TermQuery(new Term("foo", "bar"));
         searcher.search(query, 1);
@@ -149,7 +169,7 @@ public void testBasic() throws IOException {
     }
 
     public void testNoScoring() throws IOException {
-        QueryProfiler profiler = new QueryProfiler(false);
+        QueryProfiler profiler = new QueryProfiler(executor != null);
         searcher.setProfiler(profiler);
         Query query = new TermQuery(new Term("foo", "bar"));
         searcher.search(query, 1, Sort.INDEXORDER); // scores are not needed
@@ -175,7 +195,7 @@ public void testNoScoring() throws IOException {
     }
 
     public void testUseIndexStats() throws IOException {
-        QueryProfiler profiler = new QueryProfiler(false);
+        QueryProfiler profiler = new QueryProfiler(executor != null);
         searcher.setProfiler(profiler);
         Query query = new TermQuery(new Term("foo", "bar"));
         searcher.count(query); // will use index stats
@@ -189,7 +209,7 @@ public void testUseIndexStats() throws IOException {
     }
 
     public void testApproximations() throws IOException {
-        QueryProfiler profiler = new QueryProfiler(false);
+        QueryProfiler profiler = new QueryProfiler(executor != null);
         searcher.setProfiler(profiler);
         Query query = new RandomApproximationQuery(new TermQuery(new Term("foo", "bar")), random());
         searcher.count(query);
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 18225ba887416..414584ae19f5c 100644
--- a/server/src/test/java/org/opensearch/search/query/QueryPhaseTests.java
+++ b/server/src/test/java/org/opensearch/search/query/QueryPhaseTests.java
@@ -32,6 +32,7 @@
 
 package org.opensearch.search.query;
 
+import com.carrotsearch.randomizedtesting.annotations.ParametersFactory;
 import org.apache.lucene.analysis.standard.StandardAnalyzer;
 import org.apache.lucene.document.Document;
 import org.apache.lucene.document.Field.Store;
@@ -110,8 +111,13 @@
 
 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.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
 
 import static org.hamcrest.Matchers.anyOf;
 import static org.hamcrest.Matchers.equalTo;
@@ -130,8 +136,22 @@
 import static org.opensearch.search.query.TopDocsCollectorContext.hasInfMaxScore;
 
 public class QueryPhaseTests extends IndexShardTestCase {
-
     private IndexShard indexShard;
+    private final ExecutorService executor;
+    private final QueryPhaseSearcher queryPhaseSearcher;
+
+    @ParametersFactory
+    public static Collection<Object[]> concurrency() {
+        return Arrays.asList(
+            new Object[] { 0, QueryPhase.DEFAULT_QUERY_PHASE_SEARCHER },
+            new Object[] { 5, new ConcurrentQueryPhaseSearcher() }
+        );
+    }
+
+    public QueryPhaseTests(int concurrency, QueryPhaseSearcher queryPhaseSearcher) {
+        this.executor = (concurrency > 0) ? Executors.newFixedThreadPool(concurrency) : null;
+        this.queryPhaseSearcher = queryPhaseSearcher;
+    }
 
     @Override
     public Settings threadPoolSettings() {
@@ -147,21 +167,26 @@ public void setUp() throws Exception {
     @Override
     public void tearDown() throws Exception {
         super.tearDown();
+        if (executor != null) {
+            ThreadPool.terminate(executor, 10, TimeUnit.SECONDS);
+        }
         closeShards(indexShard);
     }
 
     private void countTestCase(Query query, IndexReader reader, boolean shouldCollectSearch, boolean shouldCollectCount) throws Exception {
-        ContextIndexSearcher searcher = shouldCollectSearch ? newContextSearcher(reader) : newEarlyTerminationContextSearcher(reader, 0);
+        ContextIndexSearcher searcher = shouldCollectSearch
+            ? newContextSearcher(reader, executor)
+            : newEarlyTerminationContextSearcher(reader, 0, executor);
         TestSearchContext context = new TestSearchContext(null, indexShard, searcher);
         context.parsedQuery(new ParsedQuery(query));
         context.setSize(0);
         context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-        final boolean rescore = QueryPhase.executeInternal(context.withCleanQueryResult());
+        final boolean rescore = QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
         assertFalse(rescore);
 
         ContextIndexSearcher countSearcher = shouldCollectCount
-            ? newContextSearcher(reader)
-            : newEarlyTerminationContextSearcher(reader, 0);
+            ? newContextSearcher(reader, executor)
+            : newEarlyTerminationContextSearcher(reader, 0, executor);
         assertEquals(countSearcher.count(query), context.queryResult().topDocs().topDocs.totalHits.value);
     }
 
@@ -236,16 +261,16 @@ public void testPostFilterDisablesCountOptimization() throws Exception {
 
         IndexReader reader = DirectoryReader.open(dir);
 
-        TestSearchContext context = new TestSearchContext(null, indexShard, newEarlyTerminationContextSearcher(reader, 0));
+        TestSearchContext context = new TestSearchContext(null, indexShard, newEarlyTerminationContextSearcher(reader, 0, executor));
         context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
         context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
 
-        QueryPhase.executeInternal(context.withCleanQueryResult());
+        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
         assertEquals(1, context.queryResult().topDocs().topDocs.totalHits.value);
 
-        context.setSearcher(newContextSearcher(reader));
+        context.setSearcher(newContextSearcher(reader, executor));
         context.parsedPostFilter(new ParsedQuery(new MatchNoDocsQuery()));
-        QueryPhase.executeInternal(context.withCleanQueryResult());
+        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
         assertEquals(0, context.queryResult().topDocs().topDocs.totalHits.value);
         reader.close();
         dir.close();
@@ -265,7 +290,7 @@ public void testTerminateAfterWithFilter() throws Exception {
 
         IndexReader reader = DirectoryReader.open(dir);
 
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader));
+        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor));
         context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
 
         context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
@@ -273,7 +298,7 @@ public void testTerminateAfterWithFilter() throws Exception {
         context.setSize(10);
         for (int i = 0; i < 10; i++) {
             context.parsedPostFilter(new ParsedQuery(new TermQuery(new Term("foo", Integer.toString(i)))));
-            QueryPhase.executeInternal(context.withCleanQueryResult());
+            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
             assertEquals(1, context.queryResult().topDocs().topDocs.totalHits.value);
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
         }
@@ -291,15 +316,15 @@ public void testMinScoreDisablesCountOptimization() throws Exception {
         w.close();
 
         IndexReader reader = DirectoryReader.open(dir);
-        TestSearchContext context = new TestSearchContext(null, indexShard, newEarlyTerminationContextSearcher(reader, 0));
+        TestSearchContext context = new TestSearchContext(null, indexShard, newEarlyTerminationContextSearcher(reader, 0, executor));
         context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
         context.setSize(0);
         context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-        QueryPhase.executeInternal(context.withCleanQueryResult());
+        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
         assertEquals(1, context.queryResult().topDocs().topDocs.totalHits.value);
 
         context.minimumScore(100);
-        QueryPhase.executeInternal(context.withCleanQueryResult());
+        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
         assertEquals(0, context.queryResult().topDocs().topDocs.totalHits.value);
         assertEquals(TotalHits.Relation.EQUAL_TO, context.queryResult().topDocs().topDocs.totalHits.relation);
         reader.close();
@@ -316,11 +341,11 @@ public void testQueryCapturesThreadPoolStats() throws Exception {
         }
         w.close();
         IndexReader reader = DirectoryReader.open(dir);
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader));
+        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor));
         context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
         context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
 
-        QueryPhase.executeInternal(context.withCleanQueryResult());
+        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
         QuerySearchResult results = context.queryResult();
         assertThat(results.serviceTimeEWMA(), greaterThanOrEqualTo(0L));
         assertThat(results.nodeQueueSize(), greaterThanOrEqualTo(0));
@@ -340,7 +365,7 @@ public void testInOrderScrollOptimization() throws Exception {
         w.close();
         IndexReader reader = DirectoryReader.open(dir);
         ScrollContext scrollContext = new ScrollContext();
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader), scrollContext);
+        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor), scrollContext);
         context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
         context.sort(new SortAndFormats(sort, new DocValueFormat[] { DocValueFormat.RAW }));
         scrollContext.lastEmittedDoc = null;
@@ -350,14 +375,14 @@ public void testInOrderScrollOptimization() throws Exception {
         int size = randomIntBetween(2, 5);
         context.setSize(size);
 
-        QueryPhase.executeInternal(context.withCleanQueryResult());
+        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
         assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
         assertNull(context.queryResult().terminatedEarly());
         assertThat(context.terminateAfter(), equalTo(0));
         assertThat(context.queryResult().getTotalHits().value, equalTo((long) numDocs));
 
-        context.setSearcher(newEarlyTerminationContextSearcher(reader, size));
-        QueryPhase.executeInternal(context.withCleanQueryResult());
+        context.setSearcher(newEarlyTerminationContextSearcher(reader, size, executor));
+        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
         assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
         assertThat(context.queryResult().getTotalHits().value, equalTo((long) numDocs));
         assertThat(context.queryResult().topDocs().topDocs.scoreDocs[0].doc, greaterThanOrEqualTo(size));
@@ -383,16 +408,16 @@ public void testTerminateAfterEarlyTermination() throws Exception {
         }
         w.close();
         final IndexReader reader = DirectoryReader.open(dir);
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader));
+        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor));
         context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
         context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
 
         context.terminateAfter(numDocs);
         {
             context.setSize(10);
-            final TestTotalHitCountCollectorManager manager = TestTotalHitCountCollectorManager.create();
+            final TestTotalHitCountCollectorManager manager = TestTotalHitCountCollectorManager.create(executor);
             context.queryCollectorManagers().put(TotalHitCountCollector.class, manager);
-            QueryPhase.executeInternal(context.withCleanQueryResult());
+            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
             assertFalse(context.queryResult().terminatedEarly());
             assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(10));
@@ -402,13 +427,13 @@ public void testTerminateAfterEarlyTermination() throws Exception {
         context.terminateAfter(1);
         {
             context.setSize(1);
-            QueryPhase.executeInternal(context.withCleanQueryResult());
+            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
             assertTrue(context.queryResult().terminatedEarly());
             assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(1L));
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
 
             context.setSize(0);
-            QueryPhase.executeInternal(context.withCleanQueryResult());
+            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
             assertTrue(context.queryResult().terminatedEarly());
             assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(1L));
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(0));
@@ -416,7 +441,7 @@ public void testTerminateAfterEarlyTermination() throws Exception {
 
         {
             context.setSize(1);
-            QueryPhase.executeInternal(context.withCleanQueryResult());
+            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
             assertTrue(context.queryResult().terminatedEarly());
             assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(1L));
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
@@ -427,23 +452,23 @@ public void testTerminateAfterEarlyTermination() throws Exception {
                 .add(new TermQuery(new Term("foo", "baz")), Occur.SHOULD)
                 .build();
             context.parsedQuery(new ParsedQuery(bq));
-            QueryPhase.executeInternal(context.withCleanQueryResult());
+            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
             assertTrue(context.queryResult().terminatedEarly());
             assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(1L));
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
 
             context.setSize(0);
             context.parsedQuery(new ParsedQuery(bq));
-            QueryPhase.executeInternal(context.withCleanQueryResult());
+            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
             assertTrue(context.queryResult().terminatedEarly());
             assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(1L));
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(0));
         }
         {
             context.setSize(1);
-            final TestTotalHitCountCollectorManager manager = TestTotalHitCountCollectorManager.create();
+            final TestTotalHitCountCollectorManager manager = TestTotalHitCountCollectorManager.create(executor, 1);
             context.queryCollectorManagers().put(TotalHitCountCollector.class, manager);
-            QueryPhase.executeInternal(context.withCleanQueryResult());
+            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
             assertTrue(context.queryResult().terminatedEarly());
             assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(1L));
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
@@ -452,9 +477,9 @@ public void testTerminateAfterEarlyTermination() throws Exception {
         }
         {
             context.setSize(0);
-            final TestTotalHitCountCollectorManager manager = TestTotalHitCountCollectorManager.create();
+            final TestTotalHitCountCollectorManager manager = TestTotalHitCountCollectorManager.create(executor, 1);
             context.queryCollectorManagers().put(TotalHitCountCollector.class, manager);
-            QueryPhase.executeInternal(context.withCleanQueryResult());
+            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
             assertTrue(context.queryResult().terminatedEarly());
             assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(1L));
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(0));
@@ -466,9 +491,9 @@ public void testTerminateAfterEarlyTermination() throws Exception {
         context.setSize(0);
         for (int trackTotalHits : new int[] { -1, 3, 76, 100 }) {
             context.trackTotalHitsUpTo(trackTotalHits);
-            final TestTotalHitCountCollectorManager manager = TestTotalHitCountCollectorManager.create();
+            final TestTotalHitCountCollectorManager manager = TestTotalHitCountCollectorManager.create(executor);
             context.queryCollectorManagers().put(TotalHitCountCollector.class, manager);
-            QueryPhase.executeInternal(context.withCleanQueryResult());
+            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
             assertTrue(context.queryResult().terminatedEarly());
             if (trackTotalHits == -1) {
                 assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(0L));
@@ -476,14 +501,20 @@ public void testTerminateAfterEarlyTermination() throws Exception {
                 assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) Math.min(trackTotalHits, 10)));
             }
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(0));
-            assertThat(manager.getTotalHits(), equalTo(10));
+            // The concurrent search terminates the collection when the number of hits is reached by each
+            // concurrent collector. In this case, in general, the number of results are multiplied by the number of
+            // slices (as the unit of concurrency). To address that, we have to use the shared global state,
+            // much as HitsThresholdChecker does.
+            if (executor == null) {
+                assertThat(manager.getTotalHits(), equalTo(10));
+            }
         }
 
         context.terminateAfter(7);
         context.setSize(10);
         for (int trackTotalHits : new int[] { -1, 3, 75, 100 }) {
             context.trackTotalHitsUpTo(trackTotalHits);
-            QueryPhase.executeInternal(context.withCleanQueryResult());
+            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
             assertTrue(context.queryResult().terminatedEarly());
             if (trackTotalHits == -1) {
                 assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(0L));
@@ -516,13 +547,13 @@ public void testIndexSortingEarlyTermination() throws Exception {
         w.close();
 
         final IndexReader reader = DirectoryReader.open(dir);
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader));
+        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor));
         context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
         context.setSize(1);
         context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
         context.sort(new SortAndFormats(sort, new DocValueFormat[] { DocValueFormat.RAW }));
 
-        QueryPhase.executeInternal(context.withCleanQueryResult());
+        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
         assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
         assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
         assertThat(context.queryResult().topDocs().topDocs.scoreDocs[0], instanceOf(FieldDoc.class));
@@ -531,7 +562,7 @@ public void testIndexSortingEarlyTermination() throws Exception {
 
         {
             context.parsedPostFilter(new ParsedQuery(new MinDocQuery(1)));
-            QueryPhase.executeInternal(context.withCleanQueryResult());
+            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
             assertNull(context.queryResult().terminatedEarly());
             assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(numDocs - 1L));
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
@@ -539,28 +570,30 @@ public void testIndexSortingEarlyTermination() throws Exception {
             assertThat(fieldDoc.fields[0], anyOf(equalTo(1), equalTo(2)));
             context.parsedPostFilter(null);
 
-            final TestTotalHitCountCollectorManager manager = TestTotalHitCountCollectorManager.create(sort);
+            final TestTotalHitCountCollectorManager manager = TestTotalHitCountCollectorManager.create(executor, sort);
             context.queryCollectorManagers().put(TotalHitCountCollector.class, manager);
-            QueryPhase.executeInternal(context.withCleanQueryResult());
+            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
             assertNull(context.queryResult().terminatedEarly());
             assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs[0], instanceOf(FieldDoc.class));
             assertThat(fieldDoc.fields[0], anyOf(equalTo(1), equalTo(2)));
-            assertThat(manager.getTotalHits(), equalTo(numDocs));
+            // When searching concurrently, each executors short-circuits when "size" is reached,
+            // including total hits collector
+            assertThat(manager.getTotalHits(), lessThanOrEqualTo(numDocs));
             context.queryCollectorManagers().clear();
         }
 
         {
-            context.setSearcher(newEarlyTerminationContextSearcher(reader, 1));
+            context.setSearcher(newEarlyTerminationContextSearcher(reader, 1, executor));
             context.trackTotalHitsUpTo(SearchContext.TRACK_TOTAL_HITS_DISABLED);
-            QueryPhase.executeInternal(context.withCleanQueryResult());
+            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
             assertNull(context.queryResult().terminatedEarly());
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs[0], instanceOf(FieldDoc.class));
             assertThat(fieldDoc.fields[0], anyOf(equalTo(1), equalTo(2)));
 
-            QueryPhase.executeInternal(context.withCleanQueryResult());
+            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
             assertNull(context.queryResult().terminatedEarly());
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs[0], instanceOf(FieldDoc.class));
@@ -594,7 +627,7 @@ public void testIndexSortScrollOptimization() throws Exception {
         searchSortAndFormats.add(new SortAndFormats(new Sort(indexSort.getSort()[0]), new DocValueFormat[] { DocValueFormat.RAW }));
         for (SortAndFormats searchSortAndFormat : searchSortAndFormats) {
             ScrollContext scrollContext = new ScrollContext();
-            TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader), scrollContext);
+            TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor), scrollContext);
             context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
             scrollContext.lastEmittedDoc = null;
             scrollContext.maxScore = Float.NaN;
@@ -603,7 +636,7 @@ public void testIndexSortScrollOptimization() throws Exception {
             context.setSize(10);
             context.sort(searchSortAndFormat);
 
-            QueryPhase.executeInternal(context.withCleanQueryResult());
+            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
             assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
             assertNull(context.queryResult().terminatedEarly());
             assertThat(context.terminateAfter(), equalTo(0));
@@ -611,8 +644,8 @@ public void testIndexSortScrollOptimization() throws Exception {
             int sizeMinus1 = context.queryResult().topDocs().topDocs.scoreDocs.length - 1;
             FieldDoc lastDoc = (FieldDoc) context.queryResult().topDocs().topDocs.scoreDocs[sizeMinus1];
 
-            context.setSearcher(newEarlyTerminationContextSearcher(reader, 10));
-            QueryPhase.executeInternal(context.withCleanQueryResult());
+            context.setSearcher(newEarlyTerminationContextSearcher(reader, 10, executor));
+            QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
             assertNull(context.queryResult().terminatedEarly());
             assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
             assertThat(context.terminateAfter(), equalTo(0));
@@ -654,7 +687,7 @@ public void testDisableTopScoreCollection() throws Exception {
         w.close();
 
         IndexReader reader = DirectoryReader.open(dir);
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader));
+        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor));
         context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
         Query q = new SpanNearQuery.Builder("title", true).addClause(new SpanTermQuery(new Term("title", "foo")))
             .addClause(new SpanTermQuery(new Term("title", "bar")))
@@ -665,7 +698,7 @@ public void testDisableTopScoreCollection() throws Exception {
         context.trackTotalHitsUpTo(3);
         TopDocsCollectorContext topDocsContext = TopDocsCollectorContext.createTopDocsCollectorContext(context, false);
         assertEquals(topDocsContext.create(null).scoreMode(), org.apache.lucene.search.ScoreMode.COMPLETE);
-        QueryPhase.executeInternal(context.withCleanQueryResult());
+        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
         assertEquals(numDocs / 2, context.queryResult().topDocs().topDocs.totalHits.value);
         assertEquals(context.queryResult().topDocs().topDocs.totalHits.relation, TotalHits.Relation.EQUAL_TO);
         assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(3));
@@ -673,7 +706,7 @@ public void testDisableTopScoreCollection() throws Exception {
         context.sort(new SortAndFormats(new Sort(new SortField("other", SortField.Type.INT)), new DocValueFormat[] { DocValueFormat.RAW }));
         topDocsContext = TopDocsCollectorContext.createTopDocsCollectorContext(context, false);
         assertEquals(topDocsContext.create(null).scoreMode(), org.apache.lucene.search.ScoreMode.TOP_DOCS);
-        QueryPhase.executeInternal(context.withCleanQueryResult());
+        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
         assertEquals(numDocs / 2, context.queryResult().topDocs().topDocs.totalHits.value);
         assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(3));
         assertEquals(context.queryResult().topDocs().topDocs.totalHits.relation, TotalHits.Relation.GREATER_THAN_OR_EQUAL_TO);
@@ -730,79 +763,79 @@ public void testEnhanceSortOnNumeric() throws Exception {
 
         // 1. Test a sort on long field
         {
-            TestSearchContext searchContext = spy(new TestSearchContext(null, indexShard, newContextSearcher(reader)));
+            TestSearchContext searchContext = spy(new TestSearchContext(null, indexShard, newContextSearcher(reader, executor)));
             when(searchContext.mapperService()).thenReturn(mapperService);
             searchContext.sort(longSortAndFormats);
             searchContext.parsedQuery(query);
             searchContext.setTask(task);
             searchContext.setSize(10);
-            QueryPhase.executeInternal(searchContext.withCleanQueryResult());
+            QueryPhase.executeInternal(searchContext.withCleanQueryResult(), queryPhaseSearcher);
             assertSortResults(searchContext.queryResult().topDocs().topDocs, (long) numDocs, false);
         }
 
         // 2. Test a sort on long field + date field
         {
-            TestSearchContext searchContext = spy(new TestSearchContext(null, indexShard, newContextSearcher(reader)));
+            TestSearchContext searchContext = spy(new TestSearchContext(null, indexShard, newContextSearcher(reader, executor)));
             when(searchContext.mapperService()).thenReturn(mapperService);
             searchContext.sort(longDateSortAndFormats);
             searchContext.parsedQuery(query);
             searchContext.setTask(task);
             searchContext.setSize(10);
-            QueryPhase.executeInternal(searchContext.withCleanQueryResult());
+            QueryPhase.executeInternal(searchContext.withCleanQueryResult(), queryPhaseSearcher);
             assertSortResults(searchContext.queryResult().topDocs().topDocs, (long) numDocs, true);
         }
 
         // 3. Test a sort on date field
         {
-            TestSearchContext searchContext = spy(new TestSearchContext(null, indexShard, newContextSearcher(reader)));
+            TestSearchContext searchContext = spy(new TestSearchContext(null, indexShard, newContextSearcher(reader, executor)));
             when(searchContext.mapperService()).thenReturn(mapperService);
             searchContext.sort(dateSortAndFormats);
             searchContext.parsedQuery(query);
             searchContext.setTask(task);
             searchContext.setSize(10);
-            QueryPhase.executeInternal(searchContext.withCleanQueryResult());
+            QueryPhase.executeInternal(searchContext.withCleanQueryResult(), queryPhaseSearcher);
             assertSortResults(searchContext.queryResult().topDocs().topDocs, (long) numDocs, false);
         }
 
         // 4. Test a sort on date field + long field
         {
-            TestSearchContext searchContext = spy(new TestSearchContext(null, indexShard, newContextSearcher(reader)));
+            TestSearchContext searchContext = spy(new TestSearchContext(null, indexShard, newContextSearcher(reader, executor)));
             when(searchContext.mapperService()).thenReturn(mapperService);
             searchContext.sort(dateLongSortAndFormats);
             searchContext.parsedQuery(query);
             searchContext.setTask(task);
             searchContext.setSize(10);
-            QueryPhase.executeInternal(searchContext);
+            QueryPhase.executeInternal(searchContext, queryPhaseSearcher);
             assertSortResults(searchContext.queryResult().topDocs().topDocs, (long) numDocs, true);
         }
 
         // 5. Test that sort optimization is run when from > 0 and size = 0
         {
-            TestSearchContext searchContext = spy(new TestSearchContext(null, indexShard, newContextSearcher(reader)));
+            TestSearchContext searchContext = spy(new TestSearchContext(null, indexShard, newContextSearcher(reader, executor)));
             when(searchContext.mapperService()).thenReturn(mapperService);
             searchContext.sort(longSortAndFormats);
             searchContext.parsedQuery(query);
             searchContext.setTask(task);
             searchContext.from(5);
             searchContext.setSize(0);
-            QueryPhase.executeInternal(searchContext.withCleanQueryResult());
+            QueryPhase.executeInternal(searchContext.withCleanQueryResult(), queryPhaseSearcher);
             assertSortResults(searchContext.queryResult().topDocs().topDocs, (long) numDocs, false);
         }
 
         // 6. Test that sort optimization works with from = 0 and size= 0
         {
-            TestSearchContext searchContext = spy(new TestSearchContext(null, indexShard, newContextSearcher(reader)));
+            TestSearchContext searchContext = spy(new TestSearchContext(null, indexShard, newContextSearcher(reader, executor)));
             when(searchContext.mapperService()).thenReturn(mapperService);
             searchContext.sort(longSortAndFormats);
             searchContext.parsedQuery(query);
             searchContext.setTask(task);
             searchContext.setSize(0);
-            QueryPhase.executeInternal(searchContext);
+            QueryPhase.executeInternal(searchContext, queryPhaseSearcher);
         }
 
         // 7. Test that sort optimization works with search after
         {
-            TestSearchContext searchContext = spy(new TestSearchContext(null, indexShard, newContextSearcher(reader)));
+            TestSearchContext searchContext = spy(new TestSearchContext(null, indexShard, newContextSearcher(reader, executor)));
             when(searchContext.mapperService()).thenReturn(mapperService);
             int afterDocument = (int) randomLongBetween(0, 50);
             long afterValue = firstValue + afterDocument;
@@ -812,7 +845,7 @@ public void testEnhanceSortOnNumeric() throws Exception {
             searchContext.parsedQuery(query);
             searchContext.setTask(task);
             searchContext.setSize(10);
-            QueryPhase.executeInternal(searchContext.withCleanQueryResult());
+            QueryPhase.executeInternal(searchContext.withCleanQueryResult(), queryPhaseSearcher);
             final TopDocs topDocs = searchContext.queryResult().topDocs().topDocs;
             long topValue = (long) ((FieldDoc) topDocs.scoreDocs[0]).fields[0];
             assertThat(topValue, greaterThan(afterValue));
@@ -919,7 +952,7 @@ public void testMinScore() throws Exception {
         w.close();
 
         IndexReader reader = DirectoryReader.open(dir);
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader));
+        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor));
         context.parsedQuery(
             new ParsedQuery(
                 new BooleanQuery.Builder().add(new TermQuery(new Term("foo", "bar")), Occur.MUST)
@@ -932,7 +965,7 @@ public void testMinScore() throws Exception {
         context.setSize(1);
         context.trackTotalHitsUpTo(5);
 
-        QueryPhase.executeInternal(context.withCleanQueryResult());
+        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
         assertEquals(10, context.queryResult().topDocs().topDocs.totalHits.value);
 
         reader.close();
@@ -956,7 +989,7 @@ public void testMaxScore() throws Exception {
         w.close();
 
         IndexReader reader = DirectoryReader.open(dir);
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader));
+        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor));
         context.trackScores(true);
         context.parsedQuery(
             new ParsedQuery(
@@ -969,19 +1002,19 @@ public void testMaxScore() throws Exception {
         context.setSize(1);
         context.trackTotalHitsUpTo(5);
 
-        QueryPhase.executeInternal(context.withCleanQueryResult());
+        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
         assertFalse(Float.isNaN(context.queryResult().getMaxScore()));
         assertEquals(1, context.queryResult().topDocs().topDocs.scoreDocs.length);
         assertThat(context.queryResult().topDocs().topDocs.totalHits.value, greaterThanOrEqualTo(6L));
 
         context.sort(new SortAndFormats(sort, new DocValueFormat[] { DocValueFormat.RAW }));
-        QueryPhase.executeInternal(context.withCleanQueryResult());
+        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
         assertFalse(Float.isNaN(context.queryResult().getMaxScore()));
         assertEquals(1, context.queryResult().topDocs().topDocs.scoreDocs.length);
         assertThat(context.queryResult().topDocs().topDocs.totalHits.value, greaterThanOrEqualTo(6L));
 
         context.trackScores(false);
-        QueryPhase.executeInternal(context.withCleanQueryResult());
+        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
         assertTrue(Float.isNaN(context.queryResult().getMaxScore()));
         assertEquals(1, context.queryResult().topDocs().topDocs.scoreDocs.length);
         assertThat(context.queryResult().topDocs().topDocs.totalHits.value, greaterThanOrEqualTo(6L));
@@ -1012,7 +1045,7 @@ public void testCollapseQuerySearchResults() throws Exception {
             new NumberFieldType("user", NumberType.INTEGER, true, false, true, false, null, Collections.emptyMap())
         );
 
-        TestSearchContext context = new TestSearchContext(queryShardContext, indexShard, newContextSearcher(reader));
+        TestSearchContext context = new TestSearchContext(queryShardContext, indexShard, newContextSearcher(reader, executor));
         context.collapse(new CollapseBuilder("user").build(context.getQueryShardContext()));
         context.trackScores(true);
         context.parsedQuery(new ParsedQuery(new TermQuery(new Term("foo", "bar"))));
@@ -1020,7 +1053,7 @@ public void testCollapseQuerySearchResults() throws Exception {
         context.setSize(2);
         context.trackTotalHitsUpTo(5);
 
-        QueryPhase.executeInternal(context.withCleanQueryResult());
+        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
         assertFalse(Float.isNaN(context.queryResult().getMaxScore()));
         assertEquals(2, context.queryResult().topDocs().topDocs.scoreDocs.length);
         assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
@@ -1032,7 +1065,7 @@ public void testCollapseQuerySearchResults() throws Exception {
         assertThat(topDocs.collapseValues[1], equalTo(1L)); // user == 1
 
         context.sort(new SortAndFormats(sort, new DocValueFormat[] { DocValueFormat.RAW }));
-        QueryPhase.executeInternal(context.withCleanQueryResult());
+        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
         assertFalse(Float.isNaN(context.queryResult().getMaxScore()));
         assertEquals(2, context.queryResult().topDocs().topDocs.scoreDocs.length);
         assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
@@ -1044,7 +1077,7 @@ public void testCollapseQuerySearchResults() throws Exception {
         assertThat(topDocs.collapseValues[1], equalTo(1L)); // user == 1
 
         context.trackScores(false);
-        QueryPhase.executeInternal(context.withCleanQueryResult());
+        QueryPhase.executeInternal(context.withCleanQueryResult(), queryPhaseSearcher);
         assertTrue(Float.isNaN(context.queryResult().getMaxScore()));
         assertEquals(2, context.queryResult().topDocs().topDocs.scoreDocs.length);
         assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
@@ -1075,7 +1108,11 @@ public void testCancellationDuringPreprocess() throws IOException {
             w.close();
 
             try (IndexReader reader = DirectoryReader.open(dir)) {
-                TestSearchContext context = new TestSearchContextWithRewriteAndCancellation(null, indexShard, newContextSearcher(reader));
+                TestSearchContext context = new TestSearchContextWithRewriteAndCancellation(
+                    null,
+                    indexShard,
+                    newContextSearcher(reader, executor)
+                );
                 PrefixQuery prefixQuery = new PrefixQuery(new Term("foo", "a"), MultiTermQuery.SCORING_BOOLEAN_REWRITE);
                 context.parsedQuery(new ParsedQuery(prefixQuery));
                 SearchShardTask task = mock(SearchShardTask.class);
@@ -1163,25 +1200,26 @@ public boolean lowLevelCancellation() {
         }
     }
 
-    private static ContextIndexSearcher newContextSearcher(IndexReader reader) throws IOException {
+    private static ContextIndexSearcher newContextSearcher(IndexReader reader, ExecutorService executor) throws IOException {
         return new ContextIndexSearcher(
             reader,
             IndexSearcher.getDefaultSimilarity(),
             IndexSearcher.getDefaultQueryCache(),
             IndexSearcher.getDefaultQueryCachingPolicy(),
             true,
-            null
+            executor
         );
     }
 
-    private static ContextIndexSearcher newEarlyTerminationContextSearcher(IndexReader reader, int size) throws IOException {
+    private static ContextIndexSearcher newEarlyTerminationContextSearcher(IndexReader reader, int size, ExecutorService executor)
+        throws IOException {
         return new ContextIndexSearcher(
             reader,
             IndexSearcher.getDefaultSimilarity(),
             IndexSearcher.getDefaultQueryCache(),
             IndexSearcher.getDefaultQueryCachingPolicy(),
             true,
-            null
+            executor
         ) {
 
             @Override
@@ -1193,28 +1231,62 @@ public void search(List<LeafReaderContext> leaves, Weight weight, Collector coll
     }
 
     private static class TestTotalHitCountCollectorManager extends TotalHitCountCollectorManager {
+        private int totalHits;
         private final TotalHitCountCollector collector;
+        private final Integer teminateAfter;
+
+        static TestTotalHitCountCollectorManager create(final ExecutorService executor) {
+            return create(executor, null, null);
+        }
+
+        static TestTotalHitCountCollectorManager create(final ExecutorService executor, final Integer teminateAfter) {
+            return create(executor, null, teminateAfter);
+        }
 
-        static TestTotalHitCountCollectorManager create() {
-            return create(null);
+        static TestTotalHitCountCollectorManager create(final ExecutorService executor, final Sort sort) {
+            return create(executor, sort, null);
         }
 
-        static TestTotalHitCountCollectorManager create(final Sort sort) {
-            return new TestTotalHitCountCollectorManager(new TotalHitCountCollector(), sort);
+        static TestTotalHitCountCollectorManager create(final ExecutorService executor, final Sort sort, final Integer teminateAfter) {
+            if (executor == null) {
+                return new TestTotalHitCountCollectorManager(new TotalHitCountCollector(), sort);
+            } else {
+                return new TestTotalHitCountCollectorManager(sort, teminateAfter);
+            }
         }
 
         private TestTotalHitCountCollectorManager(final TotalHitCountCollector collector, final Sort sort) {
             super(sort);
             this.collector = collector;
+            this.teminateAfter = null;
+        }
+
+        private TestTotalHitCountCollectorManager(final Sort sort, final Integer teminateAfter) {
+            super(sort);
+            this.collector = null;
+            this.teminateAfter = teminateAfter;
         }
 
         @Override
         public TotalHitCountCollector newCollector() throws IOException {
-            return collector;
+            return (collector == null) ? super.newCollector() : collector;
+        }
+
+        @Override
+        public ReduceableSearchResult reduce(Collection<TotalHitCountCollector> collectors) throws IOException {
+            final ReduceableSearchResult result = super.reduce(collectors);
+            totalHits = collectors.stream().mapToInt(TotalHitCountCollector::getTotalHits).sum();
+
+            if (teminateAfter != null) {
+                assertThat(totalHits, greaterThanOrEqualTo(teminateAfter));
+                totalHits = Math.min(totalHits, teminateAfter);
+            }
+
+            return result;
         }
 
         public int getTotalHits() {
-            return collector.getTotalHits();
+            return (collector == null) ? totalHits : collector.getTotalHits();
         }
     }
 
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 98e23c90aa7ff..5bd2cd5ee8beb 100644
--- a/server/src/test/java/org/opensearch/search/query/QueryProfilePhaseTests.java
+++ b/server/src/test/java/org/opensearch/search/query/QueryProfilePhaseTests.java
@@ -8,6 +8,7 @@
 
 package org.opensearch.search.query;
 
+import com.carrotsearch.randomizedtesting.annotations.ParametersFactory;
 import org.apache.lucene.analysis.standard.StandardAnalyzer;
 import org.apache.lucene.document.Document;
 import org.apache.lucene.document.Field.Store;
@@ -66,6 +67,7 @@
 import org.opensearch.search.profile.query.QueryProfileShardResult;
 import org.opensearch.search.sort.SortAndFormats;
 import org.opensearch.test.TestSearchContext;
+import org.opensearch.threadpool.ThreadPool;
 
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
@@ -73,8 +75,12 @@
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
 import java.util.function.Consumer;
 
 import static org.hamcrest.CoreMatchers.not;
@@ -90,8 +96,22 @@
 import static org.hamcrest.Matchers.hasSize;
 
 public class QueryProfilePhaseTests extends IndexShardTestCase {
-
     private IndexShard indexShard;
+    private final ExecutorService executor;
+    private final QueryPhaseSearcher queryPhaseSearcher;
+
+    @ParametersFactory
+    public static Collection<Object[]> concurrency() {
+        return Arrays.asList(
+            new Object[] { 0, QueryPhase.DEFAULT_QUERY_PHASE_SEARCHER },
+            new Object[] { 5, new ConcurrentQueryPhaseSearcher() }
+        );
+    }
+
+    public QueryProfilePhaseTests(int concurrency, QueryPhaseSearcher queryPhaseSearcher) {
+        this.executor = (concurrency > 0) ? Executors.newFixedThreadPool(concurrency) : null;
+        this.queryPhaseSearcher = queryPhaseSearcher;
+    }
 
     @Override
     public Settings threadPoolSettings() {
@@ -107,6 +127,9 @@ public void setUp() throws Exception {
     @Override
     public void tearDown() throws Exception {
         super.tearDown();
+        if (executor != null) {
+            ThreadPool.terminate(executor, 10, TimeUnit.SECONDS);
+        }
         closeShards(indexShard);
     }
 
@@ -121,12 +144,14 @@ public void testPostFilterDisablesCountOptimization() throws Exception {
 
         IndexReader reader = DirectoryReader.open(dir);
 
-        TestSearchContext context = new TestSearchContext(null, indexShard, newEarlyTerminationContextSearcher(reader, 0));
+        TestSearchContext context = new TestSearchContext(null, indexShard, newEarlyTerminationContextSearcher(reader, 0, executor));
         context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
         context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
 
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers());
+        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
         assertEquals(1, context.queryResult().topDocs().topDocs.totalHits.value);
+        // IndexSearcher#rewrite optimizes by rewriting non-scoring queries to ConstantScoreQuery
+        // see: https://github.com/apache/lucene/pull/672
         assertProfileData(context, "ConstantScoreQuery", query -> {
             assertThat(query.getTimeBreakdown().keySet(), not(empty()));
             assertThat(query.getTimeBreakdown().get("score"), equalTo(0L));
@@ -139,9 +164,9 @@ public void testPostFilterDisablesCountOptimization() throws Exception {
             assertThat(collector.getProfiledChildren(), empty());
         });
 
-        context.setSearcher(newContextSearcher(reader));
+        context.setSearcher(newContextSearcher(reader, executor));
         context.parsedPostFilter(new ParsedQuery(new MatchNoDocsQuery()));
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers());
+        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
         assertEquals(0, context.queryResult().topDocs().topDocs.totalHits.value);
         assertProfileData(context, collector -> {
             assertThat(collector.getReason(), equalTo("search_post_filter"));
@@ -157,6 +182,8 @@ public void testPostFilterDisablesCountOptimization() throws Exception {
             assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
             assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
         }, (query) -> {
+            // IndexSearcher#rewrite optimizes by rewriting non-scoring queries to ConstantScoreQuery
+            // see: https://github.com/apache/lucene/pull/672
             assertThat(query.getQueryName(), equalTo("ConstantScoreQuery"));
             assertThat(query.getTimeBreakdown().keySet(), not(empty()));
             assertThat(query.getTimeBreakdown().get("score"), equalTo(0L));
@@ -183,7 +210,7 @@ public void testTerminateAfterWithFilter() throws Exception {
 
         IndexReader reader = DirectoryReader.open(dir);
 
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader));
+        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor));
         context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
 
         context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
@@ -191,7 +218,7 @@ public void testTerminateAfterWithFilter() throws Exception {
         context.setSize(10);
         for (int i = 0; i < 10; i++) {
             context.parsedPostFilter(new ParsedQuery(new TermQuery(new Term("foo", Integer.toString(i)))));
-            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers());
+            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
             assertEquals(1, context.queryResult().topDocs().topDocs.totalHits.value);
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
             assertProfileData(context, collector -> {
@@ -233,11 +260,11 @@ public void testMinScoreDisablesCountOptimization() throws Exception {
         w.close();
 
         IndexReader reader = DirectoryReader.open(dir);
-        TestSearchContext context = new TestSearchContext(null, indexShard, newEarlyTerminationContextSearcher(reader, 0));
+        TestSearchContext context = new TestSearchContext(null, indexShard, newEarlyTerminationContextSearcher(reader, 0, executor));
         context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
         context.setSize(0);
         context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers());
+        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
         assertEquals(1, context.queryResult().topDocs().topDocs.totalHits.value);
         // IndexSearcher#rewrite optimizes by rewriting non-scoring queries to ConstantScoreQuery
         // see: https://github.com/apache/lucene/pull/672
@@ -254,7 +281,7 @@ public void testMinScoreDisablesCountOptimization() throws Exception {
         });
 
         context.minimumScore(100);
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers());
+        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
         assertEquals(0, context.queryResult().topDocs().topDocs.totalHits.value);
         assertEquals(TotalHits.Relation.EQUAL_TO, context.queryResult().topDocs().topDocs.totalHits.relation);
         assertProfileData(context, "MatchAllDocsQuery", query -> {
@@ -287,7 +314,7 @@ public void testInOrderScrollOptimization() throws Exception {
         w.close();
         IndexReader reader = DirectoryReader.open(dir);
         ScrollContext scrollContext = new ScrollContext();
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader), scrollContext);
+        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor), scrollContext);
         context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
         context.sort(new SortAndFormats(sort, new DocValueFormat[] { DocValueFormat.RAW }));
         scrollContext.lastEmittedDoc = null;
@@ -297,9 +324,10 @@ public void testInOrderScrollOptimization() throws Exception {
         int size = randomIntBetween(2, 5);
         context.setSize(size);
 
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers());
+        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
         assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
         assertNull(context.queryResult().terminatedEarly());
+        assertThat(context.terminateAfter(), equalTo(0));
         assertThat(context.queryResult().getTotalHits().value, equalTo((long) numDocs));
         assertProfileData(context, "ConstantScoreQuery", query -> {
             assertThat(query.getTimeBreakdown().keySet(), not(empty()));
@@ -313,8 +341,8 @@ public void testInOrderScrollOptimization() throws Exception {
             assertThat(collector.getProfiledChildren(), empty());
         });
 
-        context.setSearcher(newEarlyTerminationContextSearcher(reader, size));
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers());
+        context.setSearcher(newEarlyTerminationContextSearcher(reader, size, executor));
+        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
         assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
         assertThat(context.queryResult().getTotalHits().value, equalTo((long) numDocs));
         assertThat(context.queryResult().topDocs().topDocs.scoreDocs[0].doc, greaterThanOrEqualTo(size));
@@ -356,14 +384,14 @@ public void testTerminateAfterEarlyTermination() throws Exception {
         }
         w.close();
         final IndexReader reader = DirectoryReader.open(dir);
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader));
+        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor));
         context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
         context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
 
         context.terminateAfter(1);
         {
             context.setSize(1);
-            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers());
+            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
             assertTrue(context.queryResult().terminatedEarly());
             assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(1L));
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
@@ -382,7 +410,7 @@ public void testTerminateAfterEarlyTermination() throws Exception {
             });
 
             context.setSize(0);
-            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers());
+            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
             assertTrue(context.queryResult().terminatedEarly());
             assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(1L));
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(0));
@@ -405,7 +433,7 @@ public void testTerminateAfterEarlyTermination() throws Exception {
 
         {
             context.setSize(1);
-            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers());
+            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
             assertTrue(context.queryResult().terminatedEarly());
             assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(1L));
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
@@ -429,7 +457,7 @@ public void testTerminateAfterEarlyTermination() throws Exception {
                 .add(new TermQuery(new Term("foo", "baz")), Occur.SHOULD)
                 .build();
             context.parsedQuery(new ParsedQuery(bq));
-            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers());
+            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
             assertTrue(context.queryResult().terminatedEarly());
             assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(1L));
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
@@ -459,7 +487,7 @@ public void testTerminateAfterEarlyTermination() throws Exception {
             });
             context.setSize(0);
             context.parsedQuery(new ParsedQuery(bq));
-            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers());
+            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
             assertTrue(context.queryResult().terminatedEarly());
             assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(1L));
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(0));
@@ -511,7 +539,7 @@ public void testTerminateAfterEarlyTermination() throws Exception {
         context.setSize(10);
         for (int trackTotalHits : new int[] { -1, 3, 75, 100 }) {
             context.trackTotalHitsUpTo(trackTotalHits);
-            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers());
+            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
             assertTrue(context.queryResult().terminatedEarly());
             if (trackTotalHits == -1) {
                 assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(0L));
@@ -573,13 +601,13 @@ public void testIndexSortingEarlyTermination() throws Exception {
         w.close();
 
         final IndexReader reader = DirectoryReader.open(dir);
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader));
+        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor));
         context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
         context.setSize(1);
         context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
         context.sort(new SortAndFormats(sort, new DocValueFormat[] { DocValueFormat.RAW }));
 
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers());
+        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
         assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
         assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
         assertThat(context.queryResult().topDocs().topDocs.scoreDocs[0], instanceOf(FieldDoc.class));
@@ -601,7 +629,7 @@ public void testIndexSortingEarlyTermination() throws Exception {
 
         {
             context.parsedPostFilter(new ParsedQuery(new MinDocQuery(1)));
-            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers());
+            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
             assertNull(context.queryResult().terminatedEarly());
             assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo(numDocs - 1L));
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
@@ -634,9 +662,9 @@ public void testIndexSortingEarlyTermination() throws Exception {
         }
 
         {
-            context.setSearcher(newEarlyTerminationContextSearcher(reader, 1));
+            context.setSearcher(newEarlyTerminationContextSearcher(reader, 1, executor));
             context.trackTotalHitsUpTo(SearchContext.TRACK_TOTAL_HITS_DISABLED);
-            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers());
+            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
             assertNull(context.queryResult().terminatedEarly());
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs[0], instanceOf(FieldDoc.class));
@@ -655,7 +683,7 @@ public void testIndexSortingEarlyTermination() throws Exception {
                 assertThat(collector.getProfiledChildren(), empty());
             });
 
-            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers());
+            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
             assertNull(context.queryResult().terminatedEarly());
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(1));
             assertThat(context.queryResult().topDocs().topDocs.scoreDocs[0], instanceOf(FieldDoc.class));
@@ -703,7 +731,7 @@ public void testIndexSortScrollOptimization() throws Exception {
         searchSortAndFormats.add(new SortAndFormats(new Sort(indexSort.getSort()[0]), new DocValueFormat[] { DocValueFormat.RAW }));
         for (SortAndFormats searchSortAndFormat : searchSortAndFormats) {
             ScrollContext scrollContext = new ScrollContext();
-            TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader), scrollContext);
+            TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor), scrollContext);
             context.parsedQuery(new ParsedQuery(new MatchAllDocsQuery()));
             scrollContext.lastEmittedDoc = null;
             scrollContext.maxScore = Float.NaN;
@@ -712,7 +740,7 @@ public void testIndexSortScrollOptimization() throws Exception {
             context.setSize(10);
             context.sort(searchSortAndFormat);
 
-            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers());
+            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
             assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
             assertNull(context.queryResult().terminatedEarly());
             assertThat(context.terminateAfter(), equalTo(0));
@@ -734,8 +762,8 @@ public void testIndexSortScrollOptimization() throws Exception {
             int sizeMinus1 = context.queryResult().topDocs().topDocs.scoreDocs.length - 1;
             FieldDoc lastDoc = (FieldDoc) context.queryResult().topDocs().topDocs.scoreDocs[sizeMinus1];
 
-            context.setSearcher(newEarlyTerminationContextSearcher(reader, 10));
-            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers());
+            context.setSearcher(newEarlyTerminationContextSearcher(reader, 10, executor));
+            QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
             assertNull(context.queryResult().terminatedEarly());
             assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
             assertThat(context.terminateAfter(), equalTo(0));
@@ -764,7 +792,7 @@ public void testIndexSortScrollOptimization() throws Exception {
                 @SuppressWarnings("unchecked")
                 FieldComparator<Object> comparator = (FieldComparator<Object>) searchSortAndFormat.sort.getSort()[i].getComparator(
                     i,
-                    false
+                    randomBoolean()
                 );
                 int cmp = comparator.compareValues(firstDoc.fields[i], lastDoc.fields[i]);
                 if (cmp == 0) {
@@ -796,7 +824,7 @@ public void testDisableTopScoreCollection() throws Exception {
         w.close();
 
         IndexReader reader = DirectoryReader.open(dir);
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader));
+        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor));
         context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
         Query q = new SpanNearQuery.Builder("title", true).addClause(new SpanTermQuery(new Term("title", "foo")))
             .addClause(new SpanTermQuery(new Term("title", "bar")))
@@ -807,7 +835,7 @@ public void testDisableTopScoreCollection() throws Exception {
         context.trackTotalHitsUpTo(3);
         TopDocsCollectorContext topDocsContext = TopDocsCollectorContext.createTopDocsCollectorContext(context, false);
         assertEquals(topDocsContext.create(null).scoreMode(), org.apache.lucene.search.ScoreMode.COMPLETE);
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers());
+        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
         assertEquals(numDocs / 2, context.queryResult().topDocs().topDocs.totalHits.value);
         assertEquals(context.queryResult().topDocs().topDocs.totalHits.relation, TotalHits.Relation.EQUAL_TO);
         assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(3));
@@ -826,7 +854,7 @@ public void testDisableTopScoreCollection() throws Exception {
         context.sort(new SortAndFormats(new Sort(new SortField("other", SortField.Type.INT)), new DocValueFormat[] { DocValueFormat.RAW }));
         topDocsContext = TopDocsCollectorContext.createTopDocsCollectorContext(context, false);
         assertEquals(topDocsContext.create(null).scoreMode(), org.apache.lucene.search.ScoreMode.TOP_DOCS);
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers());
+        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
         assertEquals(numDocs / 2, context.queryResult().topDocs().topDocs.totalHits.value);
         assertThat(context.queryResult().topDocs().topDocs.scoreDocs.length, equalTo(3));
         assertEquals(context.queryResult().topDocs().topDocs.totalHits.relation, TotalHits.Relation.GREATER_THAN_OR_EQUAL_TO);
@@ -861,7 +889,7 @@ public void testMinScore() throws Exception {
         w.close();
 
         IndexReader reader = DirectoryReader.open(dir);
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader));
+        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor));
         context.parsedQuery(
             new ParsedQuery(
                 new BooleanQuery.Builder().add(new TermQuery(new Term("foo", "bar")), Occur.MUST)
@@ -874,7 +902,7 @@ public void testMinScore() throws Exception {
         context.setSize(1);
         context.trackTotalHitsUpTo(5);
 
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers());
+        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
         assertEquals(10, context.queryResult().topDocs().topDocs.totalHits.value);
         assertProfileData(context, "BooleanQuery", query -> {
             assertThat(query.getTimeBreakdown().keySet(), not(empty()));
@@ -922,7 +950,7 @@ public void testMaxScore() throws Exception {
         w.close();
 
         IndexReader reader = DirectoryReader.open(dir);
-        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader));
+        TestSearchContext context = new TestSearchContext(null, indexShard, newContextSearcher(reader, executor));
         context.trackScores(true);
         context.parsedQuery(
             new ParsedQuery(
@@ -935,7 +963,7 @@ public void testMaxScore() throws Exception {
         context.setSize(1);
         context.trackTotalHitsUpTo(5);
 
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers());
+        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
         assertFalse(Float.isNaN(context.queryResult().getMaxScore()));
         assertEquals(1, context.queryResult().topDocs().topDocs.scoreDocs.length);
         assertThat(context.queryResult().topDocs().topDocs.totalHits.value, greaterThanOrEqualTo(6L));
@@ -963,7 +991,7 @@ public void testMaxScore() throws Exception {
         });
 
         context.sort(new SortAndFormats(sort, new DocValueFormat[] { DocValueFormat.RAW }));
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers());
+        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
         assertFalse(Float.isNaN(context.queryResult().getMaxScore()));
         assertEquals(1, context.queryResult().topDocs().topDocs.scoreDocs.length);
         assertThat(context.queryResult().topDocs().topDocs.totalHits.value, greaterThanOrEqualTo(6L));
@@ -1016,7 +1044,7 @@ public void testCollapseQuerySearchResults() throws Exception {
             new NumberFieldType("user", NumberType.INTEGER, true, false, true, false, null, Collections.emptyMap())
         );
 
-        TestSearchContext context = new TestSearchContext(queryShardContext, indexShard, newContextSearcher(reader));
+        TestSearchContext context = new TestSearchContext(queryShardContext, indexShard, newContextSearcher(reader, executor));
         context.collapse(new CollapseBuilder("user").build(context.getQueryShardContext()));
         context.trackScores(true);
         context.parsedQuery(new ParsedQuery(new TermQuery(new Term("foo", "bar"))));
@@ -1024,7 +1052,7 @@ public void testCollapseQuerySearchResults() throws Exception {
         context.setSize(2);
         context.trackTotalHitsUpTo(5);
 
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers());
+        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
         assertFalse(Float.isNaN(context.queryResult().getMaxScore()));
         assertEquals(2, context.queryResult().topDocs().topDocs.scoreDocs.length);
         assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
@@ -1044,7 +1072,7 @@ public void testCollapseQuerySearchResults() throws Exception {
         });
 
         context.sort(new SortAndFormats(sort, new DocValueFormat[] { DocValueFormat.RAW }));
-        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers());
+        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
         assertFalse(Float.isNaN(context.queryResult().getMaxScore()));
         assertEquals(2, context.queryResult().topDocs().topDocs.scoreDocs.length);
         assertThat(context.queryResult().topDocs().topDocs.totalHits.value, equalTo((long) numDocs));
@@ -1129,25 +1157,26 @@ private final void assertProfileData(
         collector.accept(queryProfileShardResult.getCollectorResult());
     }
 
-    private static ContextIndexSearcher newContextSearcher(IndexReader reader) throws IOException {
+    private static ContextIndexSearcher newContextSearcher(IndexReader reader, ExecutorService executor) throws IOException {
         return new ContextIndexSearcher(
             reader,
             IndexSearcher.getDefaultSimilarity(),
             IndexSearcher.getDefaultQueryCache(),
             IndexSearcher.getDefaultQueryCachingPolicy(),
             true,
-            null
+            executor
         );
     }
 
-    private static ContextIndexSearcher newEarlyTerminationContextSearcher(IndexReader reader, int size) throws IOException {
+    private static ContextIndexSearcher newEarlyTerminationContextSearcher(IndexReader reader, int size, ExecutorService executor)
+        throws IOException {
         return new ContextIndexSearcher(
             reader,
             IndexSearcher.getDefaultSimilarity(),
             IndexSearcher.getDefaultQueryCache(),
             IndexSearcher.getDefaultQueryCachingPolicy(),
             true,
-            null
+            executor
         ) {
 
             @Override
diff --git a/server/src/test/java/org/opensearch/snapshots/SnapshotResiliencyTests.java b/server/src/test/java/org/opensearch/snapshots/SnapshotResiliencyTests.java
index f218895754b7f..3f5ef4b824afa 100644
--- a/server/src/test/java/org/opensearch/snapshots/SnapshotResiliencyTests.java
+++ b/server/src/test/java/org/opensearch/snapshots/SnapshotResiliencyTests.java
@@ -157,7 +157,6 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.transport.TransportAddress;
 import org.opensearch.common.util.BigArrays;
-import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.common.util.PageCacheRecycler;
 import org.opensearch.common.util.concurrent.AbstractRunnable;
 import org.opensearch.common.util.concurrent.PrioritizedOpenSearchThreadPoolExecutor;
@@ -1804,82 +1803,43 @@ public void onFailure(final Exception e) {
                 final SetOnce<RepositoriesService> repositoriesServiceReference = new SetOnce<>();
                 repositoriesServiceReference.set(repositoriesService);
                 FileCacheCleaner fileCacheCleaner = new FileCacheCleaner(nodeEnv, null);
-                if (FeatureFlags.isEnabled(FeatureFlags.EXTENSIONS)) {
-                    indicesService = new IndicesService(
-                        settings,
-                        mock(PluginsService.class),
-                        mock(ExtensionsManager.class),
-                        nodeEnv,
-                        namedXContentRegistry,
-                        new AnalysisRegistry(
-                            environment,
-                            emptyMap(),
-                            emptyMap(),
-                            emptyMap(),
-                            emptyMap(),
-                            emptyMap(),
-                            emptyMap(),
-                            emptyMap(),
-                            emptyMap(),
-                            emptyMap()
-                        ),
-                        indexNameExpressionResolver,
-                        mapperRegistry,
-                        namedWriteableRegistry,
-                        threadPool,
-                        indexScopedSettings,
-                        new NoneCircuitBreakerService(),
-                        bigArrays,
-                        scriptService,
-                        clusterService,
-                        client,
-                        new MetaStateService(nodeEnv, namedXContentRegistry),
-                        Collections.emptyList(),
+                indicesService = new IndicesService(
+                    settings,
+                    mock(PluginsService.class),
+                    mock(ExtensionsManager.class),
+                    nodeEnv,
+                    namedXContentRegistry,
+                    new AnalysisRegistry(
+                        environment,
                         emptyMap(),
-                        null,
                         emptyMap(),
-                        new RemoteSegmentStoreDirectoryFactory(() -> repositoriesService),
-                        repositoriesServiceReference::get,
-                        fileCacheCleaner
-                    );
-                } else {
-                    indicesService = new IndicesService(
-                        settings,
-                        mock(PluginsService.class),
-                        nodeEnv,
-                        namedXContentRegistry,
-                        new AnalysisRegistry(
-                            environment,
-                            emptyMap(),
-                            emptyMap(),
-                            emptyMap(),
-                            emptyMap(),
-                            emptyMap(),
-                            emptyMap(),
-                            emptyMap(),
-                            emptyMap(),
-                            emptyMap()
-                        ),
-                        indexNameExpressionResolver,
-                        mapperRegistry,
-                        namedWriteableRegistry,
-                        threadPool,
-                        indexScopedSettings,
-                        new NoneCircuitBreakerService(),
-                        bigArrays,
-                        scriptService,
-                        clusterService,
-                        client,
-                        new MetaStateService(nodeEnv, namedXContentRegistry),
-                        Collections.emptyList(),
                         emptyMap(),
-                        null,
                         emptyMap(),
-                        new RemoteSegmentStoreDirectoryFactory(() -> repositoriesService),
-                        repositoriesServiceReference::get,
-                        fileCacheCleaner
-                    );
-                }
+                        emptyMap(),
+                        emptyMap(),
+                        emptyMap(),
+                        emptyMap(),
+                        emptyMap()
+                    ),
+                    indexNameExpressionResolver,
+                    mapperRegistry,
+                    namedWriteableRegistry,
+                    threadPool,
+                    indexScopedSettings,
+                    new NoneCircuitBreakerService(),
+                    bigArrays,
+                    scriptService,
+                    clusterService,
+                    client,
+                    new MetaStateService(nodeEnv, namedXContentRegistry),
+                    Collections.emptyList(),
+                    emptyMap(),
+                    null,
+                    emptyMap(),
+                    new RemoteSegmentStoreDirectoryFactory(() -> repositoriesService),
+                    repositoriesServiceReference::get,
+                    fileCacheCleaner
+                );
                 final RecoverySettings recoverySettings = new RecoverySettings(settings, clusterSettings);
                 snapshotShardsService = new SnapshotShardsService(
                     settings,
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 1bb034588d20e..1d8d2dd086418 100644
--- a/test/framework/src/main/java/org/opensearch/node/MockNode.java
+++ b/test/framework/src/main/java/org/opensearch/node/MockNode.java
@@ -178,7 +178,8 @@ protected SearchService newSearchService(
             bigArrays,
             queryPhase,
             fetchPhase,
-            circuitBreakerService
+            circuitBreakerService,
+            indexSearcherExecutor
         );
     }
 
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 fd522cd298632..808dc50512c58 100644
--- a/test/framework/src/main/java/org/opensearch/search/MockSearchService.java
+++ b/test/framework/src/main/java/org/opensearch/search/MockSearchService.java
@@ -47,6 +47,7 @@
 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executor;
 import java.util.function.Consumer;
 
 public class MockSearchService extends SearchService {
@@ -94,7 +95,8 @@ public MockSearchService(
         BigArrays bigArrays,
         QueryPhase queryPhase,
         FetchPhase fetchPhase,
-        CircuitBreakerService circuitBreakerService
+        CircuitBreakerService circuitBreakerService,
+        Executor indexSearcherExecutor
     ) {
         super(
             clusterService,
@@ -106,7 +108,7 @@ public MockSearchService(
             fetchPhase,
             null,
             circuitBreakerService,
-            null
+            indexSearcherExecutor
         );
     }
 
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 eb3cb98fc113a..df2d3790d42bb 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
@@ -38,6 +38,7 @@
 import org.opensearch.action.ActionType;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.identity.IdentityService;
 import org.opensearch.indices.breaker.NoneCircuitBreakerService;
 import org.opensearch.client.node.NodeClient;
 import org.opensearch.rest.RestController;
@@ -51,6 +52,7 @@
 import org.junit.Before;
 
 import java.util.Collections;
+import java.util.List;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.BiFunction;
 
@@ -65,7 +67,15 @@ public abstract class RestActionTestCase extends OpenSearchTestCase {
     @Before
     public void setUpController() {
         verifyingClient = new VerifyingClient(this.getTestName());
-        controller = new RestController(Collections.emptySet(), null, verifyingClient, new NoneCircuitBreakerService(), new UsageService());
+        final IdentityService identityService = new IdentityService(Settings.EMPTY, List.of());
+        controller = new RestController(
+            Collections.emptySet(),
+            null,
+            verifyingClient,
+            new NoneCircuitBreakerService(),
+            new UsageService(),
+            identityService
+        );
     }
 
     @After