Put project ID args first, as Niels suggested

Author: PeteGillinElastic

x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichCache.java

@@ -84,23 +84,24 @@ private Cache<CacheKey, CacheValue> createCache(long maxWeight, ToLongBiFunction
      * This method notifies the given listener of the value in this cache for the given search parameters. If there is no value in the cache
      * for these search parameters, then the new cache value is computed using searchResponseFetcher.
      *
-     * @param enrichIndex The enrich index from which the results will be retrieved
-     * @param lookupValue The value that will be used in the search
-     * @param maxMatches The max number of matches that the search will return
+     * @param projectId             The ID of the project
+     * @param enrichIndex           The enrich index from which the results will be retrieved
+     * @param lookupValue           The value that will be used in the search
+     * @param maxMatches            The max number of matches that the search will return
      * @param searchResponseFetcher The function used to compute the value to be put in the cache, if there is no value in the cache already
-     * @param listener A listener to be notified of the value in the cache
+     * @param listener              A listener to be notified of the value in the cache
      */
     public void computeIfAbsent(
-        String enrichIndex,
         ProjectId projectId,
+        String enrichIndex,
         Object lookupValue,
         int maxMatches,
         Consumer<ActionListener<SearchResponse>> searchResponseFetcher,
         ActionListener<List<Map<?, ?>>> listener
     ) {
         // intentionally non-locking for simplicity...it's OK if we re-put the same key/value in the cache during a race condition.
         long cacheStart = relativeNanoTimeProvider.getAsLong();
-        var cacheKey = new CacheKey(enrichIndex, projectId, lookupValue, maxMatches);
+        var cacheKey = new CacheKey(projectId, enrichIndex, lookupValue, maxMatches);
         List<Map<?, ?>> response = get(cacheKey);
         long cacheRequestTime = relativeNanoTimeProvider.getAsLong() - cacheStart;
         if (response != null) {
@@ -200,11 +201,11 @@ private static Object innerDeepCopy(Object value, boolean unmodifiable) {
      *
      * @param enrichIndex The enrich <i>index</i> (i.e. not the alias, but the concrete index that the alias points to)
      * @param lookupValue The value that is used to find matches in the enrich index
-     * @param maxMatches The max number of matches that the enrich lookup should return. This changes the size of the search response and
-     * should thus be included in the cache key
+     * @param maxMatches  The max number of matches that the enrich lookup should return. This changes the size of the search response and
+     *                    should thus be included in the cache key
      */
     // Visibility for testing
-    record CacheKey(String enrichIndex, ProjectId projectId, Object lookupValue, int maxMatches) {
+    record CacheKey(ProjectId projectId, String enrichIndex, Object lookupValue, int maxMatches) {
         /**
          * In reality, the size in bytes of the cache key is a function of the {@link CacheKey#lookupValue} field plus some constant for
          * the object itself, the string reference for the enrich index (but not the string itself because it's taken from the metadata),

x-pack/plugin/enrich/src/main/java/org/elasticsearch/xpack/enrich/EnrichProcessorFactory.java

@@ -138,8 +138,8 @@ private SearchRunner createSearchRunner(ProjectMetadata project, String indexAli
         return (value, maxMatches, reqSupplier, handler) -> {
             // intentionally non-locking for simplicity...it's OK if we re-put the same key/value in the cache during a race condition.
             enrichCache.computeIfAbsent(
-                getEnrichIndexKey(project, indexAlias),
                 project.id(),
+                getEnrichIndexKey(project, indexAlias),
                 value,
                 maxMatches,
                 (searchResponseActionListener) -> originClient.execute(

x-pack/plugin/enrich/src/test/java/org/elasticsearch/xpack/enrich/EnrichCacheTests.java

@@ -40,10 +40,10 @@ public void testCaching() {
         // Emulated search requests that an enrich processor could generate:
         // (two unique searches for two enrich policies)
         var projectId = randomProjectIdOrDefault();
-        var cacheKey1 = new EnrichCache.CacheKey("policy1-1", projectId, "1", 1);
-        var cacheKey2 = new EnrichCache.CacheKey("policy1-1", projectId, "2", 1);
-        var cacheKey3 = new EnrichCache.CacheKey("policy2-1", projectId, "1", 1);
-        var cacheKey4 = new EnrichCache.CacheKey("policy2-1", projectId, "2", 1);
+        var cacheKey1 = new EnrichCache.CacheKey(projectId, "policy1-1", "1", 1);
+        var cacheKey2 = new EnrichCache.CacheKey(projectId, "policy1-1", "2", 1);
+        var cacheKey3 = new EnrichCache.CacheKey(projectId, "policy2-1", "1", 1);
+        var cacheKey4 = new EnrichCache.CacheKey(projectId, "policy2-1", "2", 1);
         // Emulated search response (content doesn't matter, since it isn't used, it just a cache entry)
         EnrichCache.CacheValue searchResponse = new EnrichCache.CacheValue(List.of(Map.of("test", "entry")), 1L);
 
@@ -77,10 +77,10 @@ public void testCaching() {
         assertThat(cacheStats.evictions(), equalTo(1L));
         assertThat(cacheStats.cacheSizeInBytes(), equalTo(3L));
 
-        cacheKey1 = new EnrichCache.CacheKey("policy1-2", projectId, "1", 1);
-        cacheKey2 = new EnrichCache.CacheKey("policy1-2", projectId, "2", 1);
-        cacheKey3 = new EnrichCache.CacheKey("policy2-2", projectId, "1", 1);
-        cacheKey4 = new EnrichCache.CacheKey("policy2-2", projectId, "2", 1);
+        cacheKey1 = new EnrichCache.CacheKey(projectId, "policy1-2", "1", 1);
+        cacheKey2 = new EnrichCache.CacheKey(projectId, "policy1-2", "2", 1);
+        cacheKey3 = new EnrichCache.CacheKey(projectId, "policy2-2", "1", 1);
+        cacheKey4 = new EnrichCache.CacheKey(projectId, "policy2-2", "2", 1);
 
         // Because enrich index has changed, cache can't serve cached entries
         assertThat(enrichCache.get(cacheKey1), nullValue());
@@ -123,7 +123,7 @@ public void testComputeIfAbsent() throws InterruptedException {
             // Do initial computeIfAbsent, assert that it is a cache miss and the search is performed:
             CountDownLatch queriedDatabaseLatch = new CountDownLatch(1);
             CountDownLatch notifiedOfResultLatch = new CountDownLatch(1);
-            enrichCache.computeIfAbsent("policy1-1", projectId, "1", 1, (searchResponseActionListener) -> {
+            enrichCache.computeIfAbsent(projectId, "policy1-1", "1", 1, (searchResponseActionListener) -> {
                 SearchResponse searchResponse = convertToSearchResponse(searchResponseMap);
                 searchResponseActionListener.onResponse(searchResponse);
                 searchResponse.decRef();
@@ -146,7 +146,7 @@ public void testComputeIfAbsent() throws InterruptedException {
         {
             // Do the same call, assert that it is a cache hit and no search is performed:
             CountDownLatch notifiedOfResultLatch = new CountDownLatch(1);
-            enrichCache.computeIfAbsent("policy1-1", projectId, "1", 1, (searchResponseActionListener) -> {
+            enrichCache.computeIfAbsent(projectId, "policy1-1", "1", 1, (searchResponseActionListener) -> {
                 fail("Expected no call to the database because item should have been in the cache");
             }, assertNoFailureListener(r -> notifiedOfResultLatch.countDown()));
             assertThat(notifiedOfResultLatch.await(5, TimeUnit.SECONDS), equalTo(true));
@@ -163,7 +163,7 @@ public void testComputeIfAbsent() throws InterruptedException {
             // Do a computeIfAbsent with a different index, assert that it is a cache miss and the search is performed:
             CountDownLatch queriedDatabaseLatch = new CountDownLatch(1);
             CountDownLatch notifiedOfResultLatch = new CountDownLatch(1);
-            enrichCache.computeIfAbsent("policy1-2", projectId, "1", 1, (searchResponseActionListener) -> {
+            enrichCache.computeIfAbsent(projectId, "policy1-2", "1", 1, (searchResponseActionListener) -> {
                 SearchResponse searchResponse = convertToSearchResponse(searchResponseMap);
                 searchResponseActionListener.onResponse(searchResponse);
                 searchResponse.decRef();
@@ -182,7 +182,7 @@ public void testComputeIfAbsent() throws InterruptedException {
             // Do a computeIfAbsent with a different project, assert that it is a cache miss and the search is performed:
             CountDownLatch queriedDatabaseLatch = new CountDownLatch(1);
             CountDownLatch notifiedOfResultLatch = new CountDownLatch(1);
-            enrichCache.computeIfAbsent("policy1-1", randomUniqueProjectId(), "1", 1, (searchResponseActionListener) -> {
+            enrichCache.computeIfAbsent(randomUniqueProjectId(), "policy1-1", "1", 1, (searchResponseActionListener) -> {
                 SearchResponse searchResponse = convertToSearchResponse(searchResponseMap);
                 searchResponseActionListener.onResponse(searchResponse);
                 searchResponse.decRef();
@@ -201,7 +201,7 @@ public void testComputeIfAbsent() throws InterruptedException {
             // Do a computeIfAbsent with a different lookup value, assert that it is a cache miss and the search is performed:
             CountDownLatch queriedDatabaseLatch = new CountDownLatch(1);
             CountDownLatch notifiedOfResultLatch = new CountDownLatch(1);
-            enrichCache.computeIfAbsent("policy1-1", projectId, "2", 1, (searchResponseActionListener) -> {
+            enrichCache.computeIfAbsent(projectId, "policy1-1", "2", 1, (searchResponseActionListener) -> {
                 SearchResponse searchResponse = convertToSearchResponse(searchResponseMap);
                 searchResponseActionListener.onResponse(searchResponse);
                 searchResponse.decRef();
@@ -220,7 +220,7 @@ public void testComputeIfAbsent() throws InterruptedException {
             // Do a computeIfAbsent with a different max matches, assert that it is a cache miss and the search is performed:
             CountDownLatch queriedDatabaseLatch = new CountDownLatch(1);
             CountDownLatch notifiedOfResultLatch = new CountDownLatch(1);
-            enrichCache.computeIfAbsent("policy1-1", projectId, "1", 3, (searchResponseActionListener) -> {
+            enrichCache.computeIfAbsent(projectId, "policy1-1", "1", 3, (searchResponseActionListener) -> {
                 SearchResponse searchResponse = convertToSearchResponse(searchResponseMap);
                 searchResponseActionListener.onResponse(searchResponse);
                 searchResponse.decRef();