fix removeUnusedPrivateMethods

Signed-off-by: Vincent Potucek <vpotucek@me.com>

Author: Vincent Potucek

DEVELOPER_GUIDE.md

@@ -76,9 +76,9 @@ Fork [opensearch-project/OpenSearch](https://github.com/opensearch-project/OpenS
 
 #### JDK
 
-OpenSearch recommends building with the [Temurin/Adoptium](https://adoptium.net/temurin/releases/) distribution. JDK 11 is the minimum supported, and JDK-24 is the newest supported. You must have a supported JDK installed with the environment variable `JAVA_HOME` referencing the path to Java home for your JDK installation, e.g. `JAVA_HOME=/usr/lib/jvm/jdk-21`. 
+OpenSearch recommends building with the [Temurin/Adoptium](https://adoptium.net/temurin/releases/) distribution. JDK 11 is the minimum supported, and JDK-24 is the newest supported. You must have a supported JDK installed with the environment variable `JAVA_HOME` referencing the path to Java home for your JDK installation, e.g. `JAVA_HOME=/usr/lib/jvm/jdk-21`.
 
-Download Java 11 from [here](https://adoptium.net/releases.html?variant=openjdk11). 
+Download Java 11 from [here](https://adoptium.net/releases.html?variant=openjdk11).
 
 
 In addition, certain backward compatibility tests check out and compile the previous major version of OpenSearch, and therefore require installing [JDK 11](https://adoptium.net/temurin/releases/?version=11) and [JDK 17](https://adoptium.net/temurin/releases/?version=17) and setting the `JAVA11_HOME` and `JAVA17_HOME` environment variables. More to that, since 8.10 release, Gradle has deprecated the usage of the any JDKs below JDK-16. For smooth development experience, the recommendation is to install at least [JDK 17](https://adoptium.net/temurin/releases/?version=17) or [JDK 21](https://adoptium.net/temurin/releases/?version=21). If you still want to build with JDK-11 only, please add `-Dorg.gradle.warning.mode=none` when invoking any Gradle build task from command line, for example:
@@ -319,17 +319,14 @@ For example, we have an hdfs test that uses mini-hdfs to test our repository-hdf
 
 ## Java Language Formatting Guidelines
 
-Java files in the OpenSearch codebase are formatted with the Eclipse JDT formatter, using the [Spotless Gradle](https://github.com/diffplug/spotless/tree/master/plugin-gradle) plugin. This plugin is configured on a project-by-project basis, via `build.gradle` in the root of the repository. So long as at least one project is configured, the formatting check can be run explicitly with:
+Java files in the OpenSearch codebase are formatted with the Eclipse JDT formatter, using the [Spotless Gradle](https://github.com/diffplug/spotless/tree/master/plugin-gradle) plugin. This plugin is configured on a project-by-project basis, via `build.gradle` in the root of the repository.
 
-    ./gradlew spotlessJavaCheck
-
-The code can be formatted with:
-
-    ./gradlew spotlessApply
-
-These tasks can also be run for specific subprojects, e.g.
-
-    ./gradlew server:spotlessJavaCheck
+- As long at least one project is configured, the formatting check can be run explicitly with:
+  - `./gradlew spotlessJavaCheck`
+- The code can be formatted with:
+  - `./gradlew spotlessApply`
+- These tasks can also be run for specific subprojects, e.g.
+  - `./gradlew server:spotlessJavaCheck`
 
 Please follow these formatting guidelines:
 
@@ -341,6 +338,43 @@ 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, it might get called out in PR reviews as something to change.
 
+## 🚀 Code Transformation & Automated Rewriting
+*(Advanced Refactoring, Modernization, and Bulk Code Changes)*
+
+### 🔧 Automated Rewriting of Source Code
+The OpenSearch build system supports **automated, large-scale code transformations** using [Moderne](https://moderne.io/) and OpenRewrite. These tools enable:
+
+- **Safe Refactoring** (e.g., renaming methods, migrating deprecated APIs)
+- **Modernization** (e.g., adopting Java 17 features like `var`, `records`, or `switch` expressions)
+- **Anti-Pattern Fixes** (e.g., replacing `Vector` with `ArrayList`, removing redundant `StringBuilder`)
+- **Convention Enforcement** (e.g., consistent JUnit test naming, `final` keyword usage)
+- **Dependency Upgrades** (e.g., automatic migration when updating library versions)
+
+### 📜 Configuration
+Rewrite rules are defined in:
+- **[code-convention.gradle](gradle/code-convention.gradle)** – Configures the OpenRewrite plugin and active recipes.
+- **[code-convention.yml](gradle/code-convention.yml)** – Custom rule definitions (e.g., project-specific patterns).
+
+### ⚙️ Usage
+- **Dry-run (check changes without applying):**
+    - Full project: `./gradlew rewriteDryRun`
+    - Subproject (e.g., `server`): `./gradlew server:rewriteDryRun`
+- **Apply transformations:**
+    - Full project: `./gradlew rewriteRun`
+    - Subproject: `./gradlew server:rewriteRun`
+
+### 🛠️ Example Transformations
+| **Before**                     | **After**                          | **Rule**                          |
+|--------------------------------|------------------------------------|-----------------------------------|
+| `new ArrayList<String>()`      | `new ArrayList<>()`                | Diamond Operator (Java 7+)        |
+| `if (x == false)`              | `if (!x)`                          | Boolean Simplification            |
+| `@Test public void testFoo()`  | `@Test void foo()`                 | JUnit 5 Convention                |
+
+### ⚠️ Notes
+- **Custom Rules**: Add project-specific rewrites in `code-convention.yml`.
+- **Exclusions**: Use `// rewrite:off` and `// rewrite:on` to opt out of transformations for specific code blocks.
+- **PR Reviews**: Automated rewrites are flagged in CI. Verify changes match intent before merging.
+
 ## 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.

build.gradle

@@ -28,25 +28,22 @@
  * under the License.
  */
 
-import java.nio.charset.StandardCharsets;
-import java.io.ByteArrayOutputStream;
 
 import com.avast.gradle.dockercompose.tasks.ComposePull
 import com.github.jengelman.gradle.plugins.shadow.ShadowPlugin
 import de.thetaphi.forbiddenapis.gradle.ForbiddenApisPlugin
 import org.apache.tools.ant.taskdefs.condition.Os
+import org.gradle.plugins.ide.eclipse.model.AccessRule
+import org.gradle.plugins.ide.eclipse.model.SourceFolder
 import org.opensearch.gradle.BuildPlugin
+import org.opensearch.gradle.CheckCompatibilityTask
 import org.opensearch.gradle.Version
 import org.opensearch.gradle.VersionProperties
 import org.opensearch.gradle.info.BuildParams
 import org.opensearch.gradle.plugin.PluginBuildPlugin
 import org.opensearch.gradle.tar.SymbolicLinkPreservingTar
-import org.gradle.plugins.ide.eclipse.model.AccessRule
-import org.gradle.plugins.ide.eclipse.model.EclipseJdt
-import org.gradle.plugins.ide.eclipse.model.SourceFolder
-import org.gradle.api.Project;
-import org.gradle.process.ExecResult;
-import org.opensearch.gradle.CheckCompatibilityTask
+
+import java.nio.charset.StandardCharsets
 
 import static org.opensearch.gradle.util.GradleUtils.maybeConfigure
 
@@ -56,6 +53,7 @@ plugins {
   id 'opensearch.global-build-info'
   id "com.diffplug.spotless" version "6.25.0" apply false
   id "org.gradle.test-retry" version "1.6.2" apply false
+  id "org.openrewrite.rewrite" version "7.11.0" apply false
   id "test-report-aggregation"
   id 'jacoco-report-aggregation'
 }
@@ -69,14 +67,39 @@ apply from: 'gradle/local-distribution.gradle'
 apply from: 'gradle/run.gradle'
 apply from: 'gradle/missing-javadoc.gradle'
 apply from: 'gradle/code-coverage.gradle'
+apply from: 'gradle/code-convention.gradle'
 
 // common maven publishing configuration
 allprojects {
   group = 'org.opensearch'
   version = VersionProperties.getOpenSearch()
   description = "OpenSearch subproject ${project.path}"
 }
-
+allprojects {
+  configurations.configureEach {
+    resolutionStrategy {
+      force(
+        'org.jetbrains:annotations:26.0.2',
+        'org.apache.commons:commons-text:1.13.1',
+        'org.ow2.asm:asm:9.8',
+        'org.ow2.asm:asm-util:9.8',
+      )
+      eachDependency { details ->
+        if (details.requested.group.startsWith('com.fasterxml.jackson')) {
+          details.useVersion '2.17.3'
+        }
+        if (details.requested.group == 'org.openrewrite.recipe' &&
+          details.requested.name == 'rewrite-java-dependencies') {
+          details.useVersion '1.37.0'
+        }
+        if (details.requested.group == 'com.google.errorprone' &&
+          details.requested.name == 'error_prone_annotations') {
+          details.useVersion '2.36.0'
+        }
+      }
+    }
+  }
+}
 configure(allprojects - project(':distribution:archives:integ-test-zip')) {
   project.pluginManager.withPlugin('nebula.maven-base-publish') {
     if (project.pluginManager.hasPlugin('opensearch.build') == false) {

gradle.properties

@@ -13,6 +13,8 @@
 org.gradle.caching=true
 org.gradle.warning.mode=none
 org.gradle.parallel=true
+# https://github.com/openrewrite/rewrite-gradle-plugin/issues/212
+org.gradle.workers.max=8
 org.gradle.jvmargs=-Xmx3g -XX:+HeapDumpOnOutOfMemoryError -Xss2m \
     --add-exports jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED \
     --add-exports jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED \

gradle/code-convention.gradle

@@ -0,0 +1,66 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/*
+ * 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.
+ */
+
+import org.opensearch.gradle.BuildPlugin
+
+import static java.lang.System.getenv
+import static java.util.Objects.isNull
+
+allprojects {
+  plugins.withType(BuildPlugin).whenPluginAdded {
+    project.apply plugin: "org.openrewrite.rewrite"
+    rewrite {
+      activeRecipe("org.opensearch.openrewrite.recipe.CodeCleanup")
+      configFile = file("$rootDir/gradle/code-convention.yml")
+      exclusions.add("**/simple-bulk11.json")
+      exclusions.add("**/simple-msearch5.json")
+      exclusions.add("**AbstractBenchmark.java")
+      exclusions.add("**OpenSearchTestCaseTests.java")
+      exclusions.add("**ScriptClassPathResolutionContext.java")
+      exclusions.add("**SearchAfterIT.java")
+      exclusions.add("**StarTreeMapper.java")
+      failOnDryRunResults = true
+    }
+    repositories {
+      mavenCentral()
+    }
+    dependencies {
+      rewrite("org.openrewrite.recipe:rewrite-rewrite:0.9.0")
+      rewrite("org.openrewrite.recipe:rewrite-static-analysis:2.12.0")
+    }
+    tasks {
+      if (!getenv("codeCleanupSkip")) { // skip on release
+        check.dependsOn(rewriteDryRun)
+        check.dependsOn(spotlessJavaCheck)
+      }
+      if (isNull(getenv("JENKINS_URL")) && getenv("codeCleanup")) { // optional for dev
+        assemble.dependsOn(rewriteRun)
+        assemble.dependsOn(spotlessApply)
+      }
+    }
+  }
+}

gradle/code-convention.yml

@@ -0,0 +1,15 @@
+type: specs.openrewrite.org/v1beta/recipe
+name: org.opensearch.openrewrite.recipe.CodeCleanup
+displayName: CodeCleanup
+description: Automatically cleanup code, e.g. remove unnecessary parentheses, simplify expressions.
+recipeList:
+#  - org.openrewrite.java.RemoveUnusedImports
+#  - org.openrewrite.staticanalysis.RemoveUnusedLocalVariables
+#  - org.openrewrite.staticanalysis.RemoveUnusedPrivateFields
+  - org.openrewrite.staticanalysis.RemoveUnusedPrivateMethods
+#  - org.openrewrite.java.OrderImports
+#  - org.openrewrite.java.format.RemoveTrailingWhitespace
+#  - org.openrewrite.staticanalysis.EmptyBlock
+#  - org.openrewrite.staticanalysis.RemoveCallsToSystemGc
+#  - org.openrewrite.staticanalysis.UnnecessaryThrows
+#  - org.openrewrite.text.EndOfLineAtEndOfFile

libs/task-commons/src/main/java/org/opensearch/task/commons/clients/TaskListRequest.java

@@ -71,16 +71,6 @@ public TaskListRequest taskType(TaskStatus... taskStatus) {
         return this;
     }
 
-    /**
-     * Update worker node to filter with in the request
-     * @param workerNode WorkerNode
-     * @return ListTaskRequest
-     */
-    private TaskListRequest workerNode(WorkerNode workerNode) {
-        this.workerNodes = workerNode;
-        return this;
-    }
-
     /**
      * Update page number to start with when fetching the list of tasks
      * @param startPageNumber startPageNumber

modules/cache-common/src/test/java/org/opensearch/cache/common/tier/TieredSpilloverCacheTests.java

@@ -2600,17 +2600,6 @@ private TieredSpilloverCache<String, String> getTieredSpilloverCache(
         return builder.build();
     }
 
-    private TieredSpilloverCache<String, String> initializeTieredSpilloverCache(
-        int keyValueSize,
-        int diskCacheSize,
-        RemovalListener<ICacheKey<String>, String> removalListener,
-        Settings settings,
-        long diskDeliberateDelay
-
-    ) {
-        return initializeTieredSpilloverCache(keyValueSize, diskCacheSize, removalListener, settings, diskDeliberateDelay, null, 256);
-    }
-
     private TieredSpilloverCache<String, String> initializeTieredSpilloverCache(
         int keyValueSize,
         int diskCacheSize,

plugins/arrow-flight-rpc/src/main/java/org/opensearch/arrow/flight/bootstrap/FlightClientManager.java

@@ -35,7 +35,6 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
-import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
@@ -247,10 +246,6 @@ private static boolean isValidNode(DiscoveryNode node) {
         return node != null && !node.getVersion().before(MIN_SUPPORTED_VERSION) && FeatureFlags.isEnabled(ARROW_STREAMS_SETTING);
     }
 
-    private Set<String> getCurrentClusterNodes() {
-        return Objects.requireNonNull(clientConfig.clusterService).state().nodes().getNodes().keySet();
-    }
-
     @VisibleForTesting
     Map<String, ClientHolder> getFlightClients() {
         return flightClients;

plugins/cache-ehcache/src/test/java/org/opensearch/cache/store/disk/EhCacheDiskCacheTests.java

@@ -1264,35 +1264,6 @@ PersistentCacheManager buildCacheManager() {
         }
     }
 
-    private EhcacheDiskCache.Builder<String, String> createDummyBuilder(String storagePath) throws IOException {
-        Settings settings = Settings.builder().build();
-        MockRemovalListener<String, String> removalListener = new MockRemovalListener<>();
-        ToLongBiFunction<ICacheKey<String>, String> weigher = getWeigher();
-        try (NodeEnvironment env = newNodeEnvironment(settings)) {
-            if (storagePath == null || storagePath.isBlank()) {
-                storagePath = env.nodePaths()[0].path.toString() + "/request_cache";
-            }
-            return (EhcacheDiskCache.Builder<String, String>) new EhcacheDiskCache.Builder<String, String>().setThreadPoolAlias(
-                "ehcacheTest"
-            )
-                .setIsEventListenerModeSync(true)
-                .setStoragePath(storagePath)
-                .setKeyType(String.class)
-                .setValueType(String.class)
-                .setKeySerializer(new StringSerializer())
-                .setDiskCacheAlias("test1")
-                .setValueSerializer(new StringSerializer())
-                .setDimensionNames(List.of(dimensionName))
-                .setCacheType(CacheType.INDICES_REQUEST_CACHE)
-                .setSettings(settings)
-                .setExpireAfterAccess(TimeValue.MAX_VALUE)
-                .setMaximumWeightInBytes(CACHE_SIZE_IN_BYTES)
-                .setRemovalListener(removalListener)
-                .setWeigher(weigher)
-                .setStatsTrackingEnabled(false);
-        }
-    }
-
     private List<String> getRandomDimensions(List<String> dimensionNames) {
         Random rand = Randomness.get();
         int bound = 3;

server/src/internalClusterTest/java/org/opensearch/cluster/routing/allocation/decider/DiskThresholdDeciderIT.java

@@ -503,12 +503,6 @@ public void testDiskMonitorResetLastRuntimeMilliSecOnlyInFirstCall() throws Exce
         }, 30L, TimeUnit.SECONDS);
     }
 
-    private String populateNode(final String dataNodeName) throws Exception {
-        final String indexName = randomAlphaOfLength(10).toLowerCase(Locale.ROOT);
-        createAndPopulateIndex(indexName, dataNodeName);
-        return indexName;
-    }
-
     private void createIndex(String indexName, String nodeName, boolean isWarmIndex) throws Exception {
         final Settings.Builder indexSettingBuilder = Settings.builder()
             .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)