Repository: opensearch-project/OpenSearch
Pull request #17769: Remove feature flag for ApproximatePointRangeQuery
Author: login: harshavamsi
Created: 2025-04-03T00:55:51Z | Merged: 2025-04-10T00:30:14Z

<!--  Thanks for sending a pull request, here are some tips:

1. If this is a fix for an undisclosed security vulnerability, please STOP. All security vulnerability reporting and fixes should be done as per our security policy https://github.com/opensearch-project/OpenSearch/security/policy
2. If this is your first time, please read our contributor guidelines: https://github.com/opensearch-project/OpenSearch/blob/main/CONTRIBUTING.md and developer guide https://github.com/opensearch-project/OpenSearch/blob/main/DEVELOPER_GUIDE.md
3. Ensure you have added or ran the appropriate tests for your PR: https://github.com/opensearch-project/OpenSearch/blob/main/TESTING.md
-->

### Description
We introduced `ApproximatePointRangeQuery` as an experimental feature flag in #13788, we're going to GA this approximate query in OS 3.0 and hence removing the feature flag.

### Related Issues
Resolves #[Issue number to be closed when this PR is merged]
<!-- List any other related issues here -->

### Check List
- [X] Functionality includes testing.
- [X] API changes companion pull request [created](https://github.com/opensearch-project/opensearch-api-specification/blob/main/DEVELOPER_GUIDE.md), if applicable.
- [X] Public documentation issue/PR [created](https://github.com/opensearch-project/documentation-website/issues/new/choose), if applicable.

By submitting this pull request, I confirm that my contribution is made under the terms of the Apache 2.0 license.
For more information on following Developer Certificate of Origin and signing off your commits, please check [here](https://github.com/opensearch-project/OpenSearch/blob/main/CONTRIBUTING.md#developer-certificate-of-origin).



Diff:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 73bac28902e21..ffc0f7a5dd929 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -62,6 +62,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ### Removed
 - Remove deprecated `batch_size` parameter from `_bulk` ([#14283](https://github.com/opensearch-project/OpenSearch/issues/14283))
+- Remove `FeatureFlags.APPROXIMATE_POINT_RANGE_QUERY_SETTING` since range query approximation is no longer experimental ([#17769](https://github.com/opensearch-project/OpenSearch/pull/17769))
 
 ### Fixed
 - Fix bytes parameter on `_cat/recovery` ([#17598](https://github.com/opensearch-project/OpenSearch/pull/17598))
diff --git a/modules/mapper-extras/src/test/java/org/opensearch/index/mapper/ScaledFloatFieldTypeTests.java b/modules/mapper-extras/src/test/java/org/opensearch/index/mapper/ScaledFloatFieldTypeTests.java
index a653edbd05992..97976d0db0b96 100644
--- a/modules/mapper-extras/src/test/java/org/opensearch/index/mapper/ScaledFloatFieldTypeTests.java
+++ b/modules/mapper-extras/src/test/java/org/opensearch/index/mapper/ScaledFloatFieldTypeTests.java
@@ -51,6 +51,7 @@
 import org.opensearch.index.fielddata.IndexNumericFieldData;
 import org.opensearch.index.fielddata.LeafNumericFieldData;
 import org.opensearch.index.fielddata.SortedNumericDoubleValues;
+import org.opensearch.search.approximate.ApproximateScoreQuery;
 
 import java.io.IOException;
 import java.util.Arrays;
@@ -167,8 +168,8 @@ public void testRoundsLowerBoundCorrectly() {
     }
 
     private String getQueryString(Query query) {
-        assertTrue(query instanceof IndexOrDocValuesQuery);
-        return ((IndexOrDocValuesQuery) query).getIndexQuery().toString();
+        assertTrue(query instanceof ApproximateScoreQuery);
+        return ((IndexOrDocValuesQuery) ((ApproximateScoreQuery) query).getOriginalQuery()).getIndexQuery().toString();
     }
 
     public void testValueForSearch() {
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 8fa914438c1c4..70461e711679e 100644
--- a/server/src/main/java/org/opensearch/common/util/FeatureFlags.java
+++ b/server/src/main/java/org/opensearch/common/util/FeatureFlags.java
@@ -122,15 +122,6 @@ public class FeatureFlags {
         Property.NodeScope
     );
 
-    /**
-     * Gates the functionality of ApproximatePointRangeQuery where we approximate query results.
-     */
-    public static final String APPROXIMATE_POINT_RANGE_QUERY = FEATURE_FLAG_PREFIX + "approximate_point_range_query.enabled";
-    public static final Setting<Boolean> APPROXIMATE_POINT_RANGE_QUERY_SETTING = Setting.boolSetting(
-        APPROXIMATE_POINT_RANGE_QUERY,
-        false,
-        Property.NodeScope
-    );
     public static final String TERM_VERSION_PRECOMMIT_ENABLE = OS_EXPERIMENTAL_PREFIX + "optimization.termversion.precommit.enabled";
     public static final Setting<Boolean> TERM_VERSION_PRECOMMIT_ENABLE_SETTING = Setting.boolSetting(
         TERM_VERSION_PRECOMMIT_ENABLE,
diff --git a/server/src/main/java/org/opensearch/index/mapper/DateFieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/DateFieldMapper.java
index ec5b128bf3173..3e96f7651aece 100644
--- a/server/src/main/java/org/opensearch/index/mapper/DateFieldMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/DateFieldMapper.java
@@ -486,23 +486,16 @@ public Query rangeQuery(
                     } else {
                         query = pointRangeQuery;
                     }
-                    if (FeatureFlags.isEnabled(FeatureFlags.APPROXIMATE_POINT_RANGE_QUERY_SETTING)) {
-                        return new ApproximateScoreQuery(
-                            query,
-                            new ApproximatePointRangeQuery(
-                                name(),
-                                pack(new long[] { l }).bytes,
-                                pack(new long[] { u }).bytes,
-                                new long[] { l }.length
-                            ) {
-                                @Override
-                                protected String toString(int dimension, byte[] value) {
-                                    return Long.toString(LongPoint.decodeDimension(value, 0));
-                                }
-                            }
-                        );
-                    }
-                    return query;
+                    return new ApproximateScoreQuery(
+                        query,
+                        new ApproximatePointRangeQuery(
+                            name(),
+                            pack(new long[] { l }).bytes,
+                            pack(new long[] { u }).bytes,
+                            new long[] { l }.length,
+                            ApproximatePointRangeQuery.LONG_FORMAT
+                        )
+                    );
                 }
 
                 // Not searchable. Must have doc values.
diff --git a/server/src/main/java/org/opensearch/index/mapper/NumberFieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/NumberFieldMapper.java
index faf3f1bb654c8..1112734247d0e 100644
--- a/server/src/main/java/org/opensearch/index/mapper/NumberFieldMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/NumberFieldMapper.java
@@ -69,6 +69,8 @@
 import org.opensearch.index.fielddata.plain.SortedNumericIndexFieldData;
 import org.opensearch.index.query.QueryShardContext;
 import org.opensearch.search.DocValueFormat;
+import org.opensearch.search.approximate.ApproximatePointRangeQuery;
+import org.opensearch.search.approximate.ApproximateScoreQuery;
 import org.opensearch.search.lookup.SearchLookup;
 import org.opensearch.search.query.BitmapDocValuesQuery;
 import org.opensearch.search.query.BitmapIndexQuery;
@@ -1058,23 +1060,34 @@ public Query rangeQuery(
                 QueryShardContext context
             ) {
                 return longRangeQuery(lowerTerm, upperTerm, includeLower, includeUpper, (l, u) -> {
-                    if (isSearchable && hasDocValues) {
-                        Query query = LongPoint.newRangeQuery(field, l, u);
-                        Query dvQuery = SortedNumericDocValuesField.newSlowRangeQuery(field, l, u);
-                        query = new IndexOrDocValuesQuery(query, dvQuery);
-                        if (context.indexSortedOnField(field)) {
-                            query = new IndexSortSortedNumericDocValuesRangeQuery(field, l, u, query);
+                    Query dvQuery = hasDocValues ? SortedNumericDocValuesField.newSlowRangeQuery(field, l, u) : null;
+                    if (isSearchable) {
+                        Query pointRangeQuery = LongPoint.newRangeQuery(field, l, u);
+                        Query query;
+                        if (dvQuery != null) {
+                            query = new IndexOrDocValuesQuery(pointRangeQuery, dvQuery);
+                            if (context.indexSortedOnField(field)) {
+                                query = new IndexSortSortedNumericDocValuesRangeQuery(field, l, u, query);
+                            }
+                        } else {
+                            query = pointRangeQuery;
                         }
-                        return query;
+                        return new ApproximateScoreQuery(
+                            query,
+                            new ApproximatePointRangeQuery(
+                                field,
+                                LongPoint.pack(new long[] { l }).bytes,
+                                LongPoint.pack(new long[] { u }).bytes,
+                                new long[] { l }.length,
+                                ApproximatePointRangeQuery.LONG_FORMAT
+                            )
+                        );
+
                     }
-                    if (hasDocValues) {
-                        Query query = SortedNumericDocValuesField.newSlowRangeQuery(field, l, u);
-                        if (context.indexSortedOnField(field)) {
-                            query = new IndexSortSortedNumericDocValuesRangeQuery(field, l, u, query);
-                        }
-                        return query;
+                    if (context.indexSortedOnField(field)) {
+                        dvQuery = new IndexSortSortedNumericDocValuesRangeQuery(field, l, u, dvQuery);
                     }
-                    return LongPoint.newRangeQuery(field, l, u);
+                    return dvQuery;
 
                 });
             }
diff --git a/server/src/main/java/org/opensearch/index/search/NestedHelper.java b/server/src/main/java/org/opensearch/index/search/NestedHelper.java
index 33094455b0382..fd8527924083a 100644
--- a/server/src/main/java/org/opensearch/index/search/NestedHelper.java
+++ b/server/src/main/java/org/opensearch/index/search/NestedHelper.java
@@ -46,6 +46,7 @@
 import org.apache.lucene.search.TermQuery;
 import org.opensearch.index.mapper.MapperService;
 import org.opensearch.index.mapper.ObjectMapper;
+import org.opensearch.search.approximate.ApproximateScoreQuery;
 
 /** Utility class to filter parent and children clauses when building nested
  * queries.
@@ -85,6 +86,8 @@ public boolean mightMatchNestedDocs(Query query) {
             return mightMatchNestedDocs(((PointRangeQuery) query).getField());
         } else if (query instanceof IndexOrDocValuesQuery) {
             return mightMatchNestedDocs(((IndexOrDocValuesQuery) query).getIndexQuery());
+        } else if (query instanceof ApproximateScoreQuery) {
+            return mightMatchNestedDocs(((ApproximateScoreQuery) query).getOriginalQuery());
         } else if (query instanceof BooleanQuery) {
             final BooleanQuery bq = (BooleanQuery) query;
             final boolean hasRequiredClauses = bq.clauses().stream().anyMatch(BooleanClause::isRequired);
@@ -155,6 +158,8 @@ public boolean mightMatchNonNestedDocs(Query query, String nestedPath) {
             return mightMatchNonNestedDocs(((PointRangeQuery) query).getField(), nestedPath);
         } else if (query instanceof IndexOrDocValuesQuery) {
             return mightMatchNonNestedDocs(((IndexOrDocValuesQuery) query).getIndexQuery(), nestedPath);
+        } else if (query instanceof ApproximateScoreQuery) {
+            return mightMatchNonNestedDocs(((ApproximateScoreQuery) query).getOriginalQuery(), nestedPath);
         } else if (query instanceof BooleanQuery) {
             final BooleanQuery bq = (BooleanQuery) query;
             final boolean hasRequiredClauses = bq.clauses().stream().anyMatch(BooleanClause::isRequired);
diff --git a/server/src/main/java/org/opensearch/search/approximate/ApproximatePointRangeQuery.java b/server/src/main/java/org/opensearch/search/approximate/ApproximatePointRangeQuery.java
index fe3d66c674a82..48f7671b21971 100644
--- a/server/src/main/java/org/opensearch/search/approximate/ApproximatePointRangeQuery.java
+++ b/server/src/main/java/org/opensearch/search/approximate/ApproximatePointRangeQuery.java
@@ -8,6 +8,7 @@
 
 package org.opensearch.search.approximate;
 
+import org.apache.lucene.document.LongPoint;
 import org.apache.lucene.index.LeafReader;
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.PointValues;
@@ -16,6 +17,7 @@
 import org.apache.lucene.search.DocIdSetIterator;
 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.PointRangeQuery;
+import org.apache.lucene.search.Query;
 import org.apache.lucene.search.QueryVisitor;
 import org.apache.lucene.search.ScoreMode;
 import org.apache.lucene.search.Scorer;
@@ -24,41 +26,51 @@
 import org.apache.lucene.util.ArrayUtil;
 import org.apache.lucene.util.DocIdSetBuilder;
 import org.apache.lucene.util.IntsRef;
-import org.opensearch.index.query.RangeQueryBuilder;
 import org.opensearch.search.internal.SearchContext;
 import org.opensearch.search.sort.FieldSortBuilder;
 import org.opensearch.search.sort.SortOrder;
 
 import java.io.IOException;
-import java.util.Arrays;
 import java.util.Objects;
+import java.util.function.Function;
 
 /**
  * An approximate-able version of {@link PointRangeQuery}. It creates an instance of {@link PointRangeQuery} but short-circuits the intersect logic
  * after {@code size} is hit
  */
-public abstract class ApproximatePointRangeQuery extends ApproximateQuery {
+public class ApproximatePointRangeQuery extends ApproximateQuery {
+    public static final Function<byte[], String> LONG_FORMAT = bytes -> Long.toString(LongPoint.decodeDimension(bytes, 0));
     private int size;
 
     private SortOrder sortOrder;
 
     public final PointRangeQuery pointRangeQuery;
 
-    protected ApproximatePointRangeQuery(String field, byte[] lowerPoint, byte[] upperPoint, int numDims) {
-        this(field, lowerPoint, upperPoint, numDims, 10_000, null);
+    public ApproximatePointRangeQuery(
+        String field,
+        byte[] lowerPoint,
+        byte[] upperPoint,
+        int numDims,
+        Function<byte[], String> valueToString
+    ) {
+        this(field, lowerPoint, upperPoint, numDims, SearchContext.DEFAULT_TRACK_TOTAL_HITS_UP_TO, null, valueToString);
     }
 
-    protected ApproximatePointRangeQuery(String field, byte[] lowerPoint, byte[] upperPoint, int numDims, int size) {
-        this(field, lowerPoint, upperPoint, numDims, size, null);
-    }
-
-    protected ApproximatePointRangeQuery(String field, byte[] lowerPoint, byte[] upperPoint, int numDims, int size, SortOrder sortOrder) {
+    protected ApproximatePointRangeQuery(
+        String field,
+        byte[] lowerPoint,
+        byte[] upperPoint,
+        int numDims,
+        int size,
+        SortOrder sortOrder,
+        Function<byte[], String> valueToString
+    ) {
         this.size = size;
         this.sortOrder = sortOrder;
         this.pointRangeQuery = new PointRangeQuery(field, lowerPoint, upperPoint, numDims) {
             @Override
             protected String toString(int dimension, byte[] value) {
-                return super.toString(field);
+                return valueToString.apply(value);
             }
         };
     }
@@ -79,6 +91,11 @@ public void setSortOrder(SortOrder sortOrder) {
         this.sortOrder = sortOrder;
     }
 
+    @Override
+    public Query rewrite(IndexSearcher indexSearcher) throws IOException {
+        return super.rewrite(indexSearcher);
+    }
+
     @Override
     public void visit(QueryVisitor visitor) {
         pointRangeQuery.visit(visitor);
@@ -344,7 +361,6 @@ public ScorerSupplier scorerSupplier(LeafReaderContext context) throws IOExcepti
                 if (checkValidPointValues(values) == false) {
                     return null;
                 }
-                final Weight weight = this;
                 if (size > values.size()) {
                     return pointRangeQueryWeight.scorerSupplier(context);
                 } else {
@@ -426,17 +442,26 @@ public boolean canApproximate(SearchContext context) {
         }
         // size 0 could be set for caching
         if (context.from() + context.size() == 0) {
-            this.setSize(10_000);
+            this.setSize(SearchContext.DEFAULT_TRACK_TOTAL_HITS_UP_TO);
+        } else {
+            this.setSize(Math.max(context.from() + context.size(), context.trackTotalHitsUpTo()));
         }
-        this.setSize(Math.max(context.from() + context.size(), context.trackTotalHitsUpTo()));
         if (context.request() != null && context.request().source() != null) {
             FieldSortBuilder primarySortField = FieldSortBuilder.getPrimaryFieldSortOrNull(context.request().source());
-            if (primarySortField != null
-                && primarySortField.missing() == null
-                && primarySortField.getFieldName().equals(((RangeQueryBuilder) context.request().source().query()).fieldName())) {
-                if (primarySortField.order() == SortOrder.DESC) {
-                    this.setSortOrder(SortOrder.DESC);
+            if (primarySortField != null) {
+                if (!primarySortField.fieldName().equals(pointRangeQuery.getField())) {
+                    return false;
+                }
+                if (primarySortField.missing() != null) {
+                    // Cannot sort documents missing this field.
+                    return false;
                 }
+                if (context.request().source().searchAfter() != null) {
+                    // TODO: We *could* optimize searchAfter, especially when this is the only sort field, but existing pruning is pretty
+                    // good.
+                    return false;
+                }
+                this.setSortOrder(primarySortField.order());
             }
         }
         return true;
@@ -453,56 +478,16 @@ public final boolean equals(Object o) {
     }
 
     private boolean equalsTo(ApproximatePointRangeQuery other) {
-        return Objects.equals(pointRangeQuery.getField(), other.pointRangeQuery.getField())
-            && pointRangeQuery.getNumDims() == other.pointRangeQuery.getNumDims()
-            && pointRangeQuery.getBytesPerDim() == other.pointRangeQuery.getBytesPerDim()
-            && Arrays.equals(pointRangeQuery.getLowerPoint(), other.pointRangeQuery.getLowerPoint())
-            && Arrays.equals(pointRangeQuery.getUpperPoint(), other.pointRangeQuery.getUpperPoint());
+        return Objects.equals(pointRangeQuery, other.pointRangeQuery);
     }
 
     @Override
     public final String toString(String field) {
         final StringBuilder sb = new StringBuilder();
-        if (pointRangeQuery.getField().equals(field) == false) {
-            sb.append(pointRangeQuery.getField());
-            sb.append(':');
-        }
-
-        // print ourselves as "range per dimension"
-        for (int i = 0; i < pointRangeQuery.getNumDims(); i++) {
-            if (i > 0) {
-                sb.append(',');
-            }
-
-            int startOffset = pointRangeQuery.getBytesPerDim() * i;
-
-            sb.append('[');
-            sb.append(
-                toString(
-                    i,
-                    ArrayUtil.copyOfSubArray(pointRangeQuery.getLowerPoint(), startOffset, startOffset + pointRangeQuery.getBytesPerDim())
-                )
-            );
-            sb.append(" TO ");
-            sb.append(
-                toString(
-                    i,
-                    ArrayUtil.copyOfSubArray(pointRangeQuery.getUpperPoint(), startOffset, startOffset + pointRangeQuery.getBytesPerDim())
-                )
-            );
-            sb.append(']');
-        }
+        sb.append("Approximate(");
+        sb.append(pointRangeQuery.toString());
+        sb.append(")");
 
         return sb.toString();
     }
-
-    /**
-     * Returns a string of a single value in a human-readable format for debugging. This is used by
-     * {@link #toString()}.
-     *
-     * @param dimension dimension of the particular value
-     * @param value     single value, never null
-     * @return human readable value for debugging
-     */
-    protected abstract String toString(int dimension, byte[] value);
 }
diff --git a/server/src/main/java/org/opensearch/search/approximate/ApproximateScoreQuery.java b/server/src/main/java/org/opensearch/search/approximate/ApproximateScoreQuery.java
index 2395142c606ae..6b39606620716 100644
--- a/server/src/main/java/org/opensearch/search/approximate/ApproximateScoreQuery.java
+++ b/server/src/main/java/org/opensearch/search/approximate/ApproximateScoreQuery.java
@@ -42,9 +42,10 @@ public ApproximateQuery getApproximationQuery() {
     }
 
     @Override
-    public final Query rewrite(IndexSearcher indexSearcher) throws IOException {
+    public Query rewrite(IndexSearcher indexSearcher) throws IOException {
         if (resolvedQuery == null) {
-            throw new IllegalStateException("Cannot rewrite resolved query without setContext being called");
+            // Default to the original query. This suggests that we were not called from ContextIndexSearcher.
+            return originalQuery.rewrite(indexSearcher);
         }
         return resolvedQuery.rewrite(indexSearcher);
     }
diff --git a/server/src/main/java/org/opensearch/search/internal/ContextIndexSearcher.java b/server/src/main/java/org/opensearch/search/internal/ContextIndexSearcher.java
index 3215759b59259..bf570a0dd0d60 100644
--- a/server/src/main/java/org/opensearch/search/internal/ContextIndexSearcher.java
+++ b/server/src/main/java/org/opensearch/search/internal/ContextIndexSearcher.java
@@ -191,6 +191,9 @@ public void setAggregatedDfs(AggregatedDfs aggregatedDfs) {
 
     @Override
     public Query rewrite(Query original) throws IOException {
+        if (original instanceof ApproximateScoreQuery) {
+            ((ApproximateScoreQuery) original).setContext(searchContext);
+        }
         if (profiler != null) {
             profiler.startRewriteTime();
         }
@@ -221,9 +224,6 @@ public Weight createWeight(Query query, ScoreMode scoreMode, float boost) throws
                 profiler.pollLastElement();
             }
             return new ProfileWeight(query, weight, profile);
-        } else if (query instanceof ApproximateScoreQuery) {
-            ((ApproximateScoreQuery) query).setContext(searchContext);
-            return super.createWeight(query, scoreMode, boost);
         } else {
             return super.createWeight(query, scoreMode, boost);
         }
diff --git a/server/src/test/java/org/opensearch/index/mapper/DateFieldTypeTests.java b/server/src/test/java/org/opensearch/index/mapper/DateFieldTypeTests.java
index e3f2f6e5ea27c..3fda7bcb1616a 100644
--- a/server/src/test/java/org/opensearch/index/mapper/DateFieldTypeTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/DateFieldTypeTests.java
@@ -65,7 +65,6 @@
 import org.opensearch.common.time.DateFormatters;
 import org.opensearch.common.time.DateMathParser;
 import org.opensearch.common.util.BigArrays;
-import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.fielddata.IndexNumericFieldData;
@@ -81,6 +80,7 @@
 import org.opensearch.index.query.QueryShardContext;
 import org.opensearch.search.approximate.ApproximatePointRangeQuery;
 import org.opensearch.search.approximate.ApproximateScoreQuery;
+import org.opensearch.test.TestSearchContext;
 import org.joda.time.DateTimeZone;
 
 import java.io.IOException;
@@ -91,9 +91,7 @@
 import java.util.List;
 import java.util.Locale;
 
-import static org.hamcrest.CoreMatchers.is;
 import static org.apache.lucene.document.LongPoint.pack;
-import static org.junit.Assume.assumeThat;
 
 public class DateFieldTypeTests extends FieldTypeTestCase {
 
@@ -239,18 +237,9 @@ public void testTermQuery() {
                 "field",
                 pack(new long[] { instant }).bytes,
                 pack(new long[] { instant + 999 }).bytes,
-                new long[] { instant }.length
-            ) {
-                @Override
-                protected String toString(int dimension, byte[] value) {
-                    return Long.toString(LongPoint.decodeDimension(value, 0));
-                }
-            }
-        );
-        assumeThat(
-            "Using Approximate Range Query as default",
-            FeatureFlags.isEnabled(FeatureFlags.APPROXIMATE_POINT_RANGE_QUERY),
-            is(true)
+                new long[] { instant }.length,
+                ApproximatePointRangeQuery.LONG_FORMAT
+            )
         );
         assertEquals(expected, ft.termQuery(date, context));
 
@@ -298,32 +287,17 @@ public void testRangeQuery() throws IOException {
         String date2 = "2016-04-28T11:33:52";
         long instant1 = DateFormatters.from(DateFieldMapper.getDefaultDateTimeFormatter().parse(date1)).toInstant().toEpochMilli();
         long instant2 = DateFormatters.from(DateFieldMapper.getDefaultDateTimeFormatter().parse(date2)).toInstant().toEpochMilli() + 999;
-        Query expected = new ApproximateScoreQuery(
-            new IndexOrDocValuesQuery(
-                LongPoint.newRangeQuery("field", instant1, instant2),
-                SortedNumericDocValuesField.newSlowRangeQuery("field", instant1, instant2)
-            ),
-            new ApproximatePointRangeQuery(
-                "field",
-                pack(new long[] { instant1 }).bytes,
-                pack(new long[] { instant2 }).bytes,
-                new long[] { instant1 }.length
-            ) {
-                @Override
-                protected String toString(int dimension, byte[] value) {
-                    return Long.toString(LongPoint.decodeDimension(value, 0));
-                }
-            }
-        );
-        assumeThat(
-            "Using Approximate Range Query as default",
-            FeatureFlags.isEnabled(FeatureFlags.APPROXIMATE_POINT_RANGE_QUERY),
-            is(true)
-        );
-        assertEquals(
-            expected,
-            ft.rangeQuery(date1, date2, true, true, null, null, null, context).rewrite(new IndexSearcher(new MultiReader()))
+        Query expected = new ApproximatePointRangeQuery(
+            "field",
+            pack(new long[] { instant1 }).bytes,
+            pack(new long[] { instant2 }).bytes,
+            new long[] { instant1 }.length,
+            ApproximatePointRangeQuery.LONG_FORMAT
         );
+        Query rangeQuery = ft.rangeQuery(date1, date2, true, true, null, null, null, context);
+        assertTrue(rangeQuery instanceof ApproximateScoreQuery);
+        ((ApproximateScoreQuery) rangeQuery).setContext(new TestSearchContext(context));
+        assertEquals(expected, rangeQuery.rewrite(new IndexSearcher(new MultiReader())));
 
         instant1 = nowInMillis;
         instant2 = instant1 + 100;
@@ -337,20 +311,11 @@ protected String toString(int dimension, byte[] value) {
                     "field",
                     pack(new long[] { instant1 }).bytes,
                     pack(new long[] { instant2 }).bytes,
-                    new long[] { instant1 }.length
-                ) {
-                    @Override
-                    protected String toString(int dimension, byte[] value) {
-                        return Long.toString(LongPoint.decodeDimension(value, 0));
-                    }
-                }
+                    new long[] { instant1 }.length,
+                    ApproximatePointRangeQuery.LONG_FORMAT
+                )
             )
         );
-        assumeThat(
-            "Using Approximate Range Query as default",
-            FeatureFlags.isEnabled(FeatureFlags.APPROXIMATE_POINT_RANGE_QUERY),
-            is(true)
-        );
         assertEquals(expected, ft.rangeQuery("now", instant2, true, true, null, null, null, context));
 
         MappedFieldType unsearchable = new DateFieldType(
@@ -408,30 +373,21 @@ public void testRangeQueryWithIndexSort() {
         long instant2 = DateFormatters.from(DateFieldMapper.getDefaultDateTimeFormatter().parse(date2)).toInstant().toEpochMilli() + 999;
 
         Query dvQuery = SortedNumericDocValuesField.newSlowRangeQuery("field", instant1, instant2);
-        Query expected = new IndexSortSortedNumericDocValuesRangeQuery(
-            "field",
-            instant1,
-            instant2,
-            new ApproximateScoreQuery(
-                new IndexOrDocValuesQuery(LongPoint.newRangeQuery("field", instant1, instant2), dvQuery),
-                new ApproximatePointRangeQuery(
-                    "field",
-                    pack(new long[] { instant1 }).bytes,
-                    pack(new long[] { instant2 }).bytes,
-                    new long[] { instant1 }.length
-                ) {
-                    @Override
-                    protected String toString(int dimension, byte[] value) {
-                        return Long.toString(LongPoint.decodeDimension(value, 0));
-                    }
-                }
+        Query expected = new ApproximateScoreQuery(
+            new IndexSortSortedNumericDocValuesRangeQuery(
+                "field",
+                instant1,
+                instant2,
+                new IndexOrDocValuesQuery(LongPoint.newRangeQuery("field", instant1, instant2), dvQuery)
+            ),
+            new ApproximatePointRangeQuery(
+                "field",
+                pack(new long[] { instant1 }).bytes,
+                pack(new long[] { instant2 }).bytes,
+                new long[] { instant1 }.length,
+                ApproximatePointRangeQuery.LONG_FORMAT
             )
         );
-        assumeThat(
-            "Using Approximate Range Query as default",
-            FeatureFlags.isEnabled(FeatureFlags.APPROXIMATE_POINT_RANGE_QUERY),
-            is(true)
-        );
         assertEquals(expected, ft.rangeQuery(date1, date2, true, true, null, null, null, context));
     }
 
diff --git a/server/src/test/java/org/opensearch/index/mapper/NumberFieldTypeTests.java b/server/src/test/java/org/opensearch/index/mapper/NumberFieldTypeTests.java
index e1551e225b307..6382f033d74d5 100644
--- a/server/src/test/java/org/opensearch/index/mapper/NumberFieldTypeTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/NumberFieldTypeTests.java
@@ -75,6 +75,8 @@
 import org.opensearch.index.query.QueryShardContext;
 import org.opensearch.search.DocValueFormat;
 import org.opensearch.search.MultiValueMode;
+import org.opensearch.search.approximate.ApproximatePointRangeQuery;
+import org.opensearch.search.approximate.ApproximateScoreQuery;
 import org.opensearch.search.query.BitmapDocValuesQuery;
 import org.opensearch.search.query.BitmapIndexQuery;
 import org.junit.Before;
@@ -96,6 +98,7 @@
 import static org.hamcrest.Matchers.either;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.instanceOf;
+import static org.apache.lucene.document.LongPoint.pack;
 
 public class NumberFieldTypeTests extends FieldTypeTestCase {
 
@@ -392,9 +395,9 @@ public void testUnsignedLongRangeQueryWithDecimalParts() {
 
     public void testLongRangeQuery() {
         MappedFieldType ft = new NumberFieldMapper.NumberFieldType("field", NumberFieldMapper.NumberType.LONG);
-        Query expected = new IndexOrDocValuesQuery(
-            LongPoint.newRangeQuery("field", 1, 3),
-            SortedNumericDocValuesField.newSlowRangeQuery("field", 1, 3)
+        Query expected = new ApproximateScoreQuery(
+            new IndexOrDocValuesQuery(LongPoint.newRangeQuery("field", 1, 3), SortedNumericDocValuesField.newSlowRangeQuery("field", 1, 3)),
+            new ApproximatePointRangeQuery("field", pack(1).bytes, pack(3).bytes, 1, ApproximatePointRangeQuery.LONG_FORMAT)
         );
         assertEquals(expected, ft.rangeQuery("1", "3", true, true, null, null, null, MOCK_QSC));
 
@@ -681,7 +684,11 @@ public void doTestDocValueRangeQueries(NumberType type, Supplier<Number> valueSu
                 true,
                 MOCK_QSC
             );
-            assertThat(query, either(instanceOf(IndexOrDocValuesQuery.class)).or(instanceOf(MatchNoDocsQuery.class)));
+            assertThat(
+                query,
+                either(instanceOf(IndexOrDocValuesQuery.class)).or(instanceOf(MatchNoDocsQuery.class))
+                    .or(instanceOf(ApproximateScoreQuery.class))
+            );
             if (query instanceof IndexOrDocValuesQuery) {
                 IndexOrDocValuesQuery indexOrDvQuery = (IndexOrDocValuesQuery) query;
                 assertEquals(searcher.count(indexOrDvQuery.getIndexQuery()), searcher.count(indexOrDvQuery.getRandomAccessQuery()));
@@ -764,10 +771,20 @@ public void doTestIndexSortRangeQueries(NumberType type, Supplier<Number> valueS
                 true,
                 context
             );
-            assertThat(query, instanceOf(IndexSortSortedNumericDocValuesRangeQuery.class));
+            assertThat(
+                query,
+                either(instanceOf(IndexSortSortedNumericDocValuesRangeQuery.class)).or(instanceOf(ApproximateScoreQuery.class))
+            );
 
-            Query fallbackQuery = ((IndexSortSortedNumericDocValuesRangeQuery) query).getFallbackQuery();
-            assertThat(fallbackQuery, instanceOf(IndexOrDocValuesQuery.class));
+            Query fallbackQuery;
+            if (query instanceof IndexSortSortedNumericDocValuesRangeQuery) {
+                fallbackQuery = ((IndexSortSortedNumericDocValuesRangeQuery) query).getFallbackQuery();
+                assertThat(fallbackQuery, instanceOf(IndexOrDocValuesQuery.class));
+            } else {
+                fallbackQuery = ((IndexSortSortedNumericDocValuesRangeQuery) ((ApproximateScoreQuery) query).getOriginalQuery())
+                    .getFallbackQuery();
+                assertThat(fallbackQuery, instanceOf(IndexOrDocValuesQuery.class));
+            }
 
             IndexOrDocValuesQuery indexOrDvQuery = (IndexOrDocValuesQuery) fallbackQuery;
             assertEquals(searcher.count(query), searcher.count(indexOrDvQuery.getIndexQuery()));
diff --git a/server/src/test/java/org/opensearch/index/mapper/RangeFieldQueryStringQueryBuilderTests.java b/server/src/test/java/org/opensearch/index/mapper/RangeFieldQueryStringQueryBuilderTests.java
index 8753f58628e82..8591a1e2bb8df 100644
--- a/server/src/test/java/org/opensearch/index/mapper/RangeFieldQueryStringQueryBuilderTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/RangeFieldQueryStringQueryBuilderTests.java
@@ -46,7 +46,6 @@
 import org.opensearch.common.compress.CompressedXContent;
 import org.opensearch.common.network.InetAddresses;
 import org.opensearch.common.time.DateMathParser;
-import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.index.query.QueryShardContext;
 import org.opensearch.index.query.QueryStringQueryBuilder;
 import org.opensearch.lucene.queries.BinaryDocValuesRangeQuery;
@@ -57,11 +56,9 @@
 import java.io.IOException;
 import java.net.InetAddress;
 
-import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.Matchers.either;
 import static org.hamcrest.core.IsInstanceOf.instanceOf;
 import static org.apache.lucene.document.LongPoint.pack;
-import static org.junit.Assume.assumeThat;
 
 public class RangeFieldQueryStringQueryBuilderTests extends AbstractQueryTestCase<QueryStringQueryBuilder> {
 
@@ -185,11 +182,6 @@ public void testDateRangeQuery() throws Exception {
             parser.parse(lowerBoundExact, () -> 0).toEpochMilli(),
             parser.parse(upperBoundExact, () -> 0).toEpochMilli()
         );
-        assumeThat(
-            "Using Approximate Range Query as default",
-            FeatureFlags.isEnabled(FeatureFlags.APPROXIMATE_POINT_RANGE_QUERY),
-            is(true)
-        );
         assertEquals(
             new ApproximateScoreQuery(
                 new IndexOrDocValuesQuery(
@@ -204,13 +196,9 @@ public void testDateRangeQuery() throws Exception {
                     DATE_FIELD_NAME,
                     pack(new long[] { parser.parse(lowerBoundExact, () -> 0).toEpochMilli() }).bytes,
                     pack(new long[] { parser.parse(upperBoundExact, () -> 0).toEpochMilli() }).bytes,
-                    new long[] { parser.parse(lowerBoundExact, () -> 0).toEpochMilli() }.length
-                ) {
-                    @Override
-                    protected String toString(int dimension, byte[] value) {
-                        return Long.toString(LongPoint.decodeDimension(value, 0));
-                    }
-                }
+                    new long[] { parser.parse(lowerBoundExact, () -> 0).toEpochMilli() }.length,
+                    ApproximatePointRangeQuery.LONG_FORMAT
+                )
             ),
             queryOnDateField
         );
diff --git a/server/src/test/java/org/opensearch/index/mapper/RangeFieldTypeTests.java b/server/src/test/java/org/opensearch/index/mapper/RangeFieldTypeTests.java
index 3fadfb9b2f976..5065c64d8f8fd 100644
--- a/server/src/test/java/org/opensearch/index/mapper/RangeFieldTypeTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/RangeFieldTypeTests.java
@@ -286,11 +286,6 @@ public void testDateRangeQueryUsingMappingFormatLegacy() {
         // compare lower and upper bounds with what we would get on a `date` field
         DateFieldType dateFieldType = new DateFieldType("field", DateFieldMapper.Resolution.MILLISECONDS, formatter);
         final Query queryOnDateField = dateFieldType.rangeQuery(from, to, true, true, relation, null, fieldType.dateMathParser(), context);
-        assumeThat(
-            "Using Approximate Range Query as default",
-            FeatureFlags.isEnabled(FeatureFlags.APPROXIMATE_POINT_RANGE_QUERY),
-            is(true)
-        );
         assertEquals(
             "field:[1465975790000 TO 1466062190999]",
             ((IndexOrDocValuesQuery) ((ApproximateScoreQuery) queryOnDateField).getOriginalQuery()).getIndexQuery().toString()
diff --git a/server/src/test/java/org/opensearch/index/query/QueryStringQueryBuilderTests.java b/server/src/test/java/org/opensearch/index/query/QueryStringQueryBuilderTests.java
index 9e2dae881d779..4458271124693 100644
--- a/server/src/test/java/org/opensearch/index/query/QueryStringQueryBuilderTests.java
+++ b/server/src/test/java/org/opensearch/index/query/QueryStringQueryBuilderTests.java
@@ -70,7 +70,6 @@
 import org.opensearch.common.compress.CompressedXContent;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.Fuzziness;
-import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.common.xcontent.json.JsonXContent;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.index.mapper.FieldNamesFieldMapper;
@@ -101,9 +100,7 @@
 import static org.hamcrest.CoreMatchers.hasItems;
 import static org.hamcrest.Matchers.containsString;
 import static org.hamcrest.Matchers.instanceOf;
-import static org.hamcrest.Matchers.is;
 import static org.apache.lucene.document.LongPoint.pack;
-import static org.junit.Assume.assumeThat;
 
 public class QueryStringQueryBuilderTests extends AbstractQueryTestCase<QueryStringQueryBuilder> {
 
@@ -853,11 +850,6 @@ public void testToQueryDateWithTimeZone() throws Exception {
         QueryStringQueryBuilder qsq = queryStringQuery(DATE_FIELD_NAME + ":1970-01-01");
         QueryShardContext context = createShardContext();
         Query query = qsq.toQuery(context);
-        assumeThat(
-            "Using Approximate Range Query as default",
-            FeatureFlags.isEnabled(FeatureFlags.APPROXIMATE_POINT_RANGE_QUERY),
-            is(true)
-        );
         assertThat(query, instanceOf(ApproximateScoreQuery.class));
         long lower = 0; // 1970-01-01T00:00:00.999 UTC
         long upper = 86399999;  // 1970-01-01T23:59:59.999 UTC
@@ -877,13 +869,9 @@ private ApproximateScoreQuery calculateExpectedDateQuery(long lower, long upper)
                 DATE_FIELD_NAME,
                 pack(new long[] { lower }).bytes,
                 pack(new long[] { upper }).bytes,
-                new long[] { lower }.length
-            ) {
-                @Override
-                protected String toString(int dimension, byte[] value) {
-                    return Long.toString(LongPoint.decodeDimension(value, 0));
-                }
-            }
+                new long[] { lower }.length,
+                ApproximatePointRangeQuery.LONG_FORMAT
+            )
         );
     }
 
diff --git a/server/src/test/java/org/opensearch/index/query/RangeQueryBuilderTests.java b/server/src/test/java/org/opensearch/index/query/RangeQueryBuilderTests.java
index 34f4657bad100..71d5d69a1c0e7 100644
--- a/server/src/test/java/org/opensearch/index/query/RangeQueryBuilderTests.java
+++ b/server/src/test/java/org/opensearch/index/query/RangeQueryBuilderTests.java
@@ -47,7 +47,6 @@
 import org.opensearch.OpenSearchParseException;
 import org.opensearch.common.geo.ShapeRelation;
 import org.opensearch.common.lucene.BytesRefs;
-import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.core.common.ParsingException;
 import org.opensearch.index.mapper.DateFieldMapper;
 import org.opensearch.index.mapper.FieldNamesFieldMapper;
@@ -69,12 +68,10 @@
 import java.util.Map;
 
 import static org.opensearch.index.query.QueryBuilders.rangeQuery;
-import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.instanceOf;
 import static org.hamcrest.Matchers.sameInstance;
 import static org.apache.lucene.document.LongPoint.pack;
-import static org.junit.Assume.assumeThat;
 
 public class RangeQueryBuilderTests extends AbstractQueryTestCase<RangeQueryBuilder> {
     @Override
@@ -190,11 +187,6 @@ protected void doAssertLuceneQuery(RangeQueryBuilder queryBuilder, Query query,
                 assertThat(termRangeQuery.includesLower(), equalTo(queryBuilder.includeLower()));
                 assertThat(termRangeQuery.includesUpper(), equalTo(queryBuilder.includeUpper()));
             } else if (expectedFieldName.equals(DATE_FIELD_NAME)) {
-                assumeThat(
-                    "Using Approximate Range Query as default",
-                    FeatureFlags.isEnabled(FeatureFlags.APPROXIMATE_POINT_RANGE_QUERY),
-                    is(true)
-                );
                 assertThat(query, instanceOf(ApproximateScoreQuery.class));
                 Query approximationQuery = ((ApproximateScoreQuery) query).getApproximationQuery();
                 assertThat(approximationQuery, instanceOf(ApproximateQuery.class));
@@ -258,13 +250,9 @@ protected void doAssertLuceneQuery(RangeQueryBuilder queryBuilder, Query query,
                             DATE_FIELD_NAME,
                             pack(new long[] { minLong }).bytes,
                             pack(new long[] { maxLong }).bytes,
-                            new long[] { minLong }.length
-                        ) {
-                            @Override
-                            protected String toString(int dimension, byte[] value) {
-                                return Long.toString(LongPoint.decodeDimension(value, 0));
-                            }
-                        }
+                            new long[] { minLong }.length,
+                            ApproximatePointRangeQuery.LONG_FORMAT
+                        )
                     ),
                     query
                 );
@@ -332,11 +320,6 @@ public void testDateRangeQueryFormat() throws IOException {
             + "    }\n"
             + "}";
         Query parsedQuery = parseQuery(query).toQuery(createShardContext());
-        assumeThat(
-            "Using Approximate Range Query as default",
-            FeatureFlags.isEnabled(FeatureFlags.APPROXIMATE_POINT_RANGE_QUERY),
-            is(true)
-        );
         assertThat(parsedQuery, instanceOf(ApproximateScoreQuery.class));
         Query approximationQuery = ((ApproximateScoreQuery) parsedQuery).getApproximationQuery();
         assertThat(approximationQuery, instanceOf(ApproximateQuery.class));
@@ -354,13 +337,9 @@ public void testDateRangeQueryFormat() throws IOException {
                     DATE_FIELD_NAME,
                     pack(new long[] { lower }).bytes,
                     pack(new long[] { upper }).bytes,
-                    new long[] { lower }.length
-                ) {
-                    @Override
-                    protected String toString(int dimension, byte[] value) {
-                        return Long.toString(LongPoint.decodeDimension(value, 0));
-                    }
-                }
+                    new long[] { lower }.length,
+                    ApproximatePointRangeQuery.LONG_FORMAT
+                )
             ),
             parsedQuery
         );
@@ -392,11 +371,6 @@ public void testDateRangeBoundaries() throws IOException {
             + "    }\n"
             + "}\n";
         Query parsedQuery = parseQuery(query).toQuery(createShardContext());
-        assumeThat(
-            "Using Approximate Range Query as default",
-            FeatureFlags.isEnabled(FeatureFlags.APPROXIMATE_POINT_RANGE_QUERY),
-            is(true)
-        );
         assertThat(parsedQuery, instanceOf(ApproximateScoreQuery.class));
 
         long lower = DateTime.parse("2014-11-01T00:00:00.000+00").getMillis();
@@ -411,13 +385,9 @@ public void testDateRangeBoundaries() throws IOException {
                     DATE_FIELD_NAME,
                     pack(new long[] { lower }).bytes,
                     pack(new long[] { upper }).bytes,
-                    new long[] { lower }.length
-                ) {
-                    @Override
-                    protected String toString(int dimension, byte[] value) {
-                        return Long.toString(LongPoint.decodeDimension(value, 0));
-                    }
-                }
+                    new long[] { lower }.length,
+                    ApproximatePointRangeQuery.LONG_FORMAT
+                )
             )
 
             ,
@@ -448,13 +418,9 @@ protected String toString(int dimension, byte[] value) {
                     DATE_FIELD_NAME,
                     pack(new long[] { lower }).bytes,
                     pack(new long[] { upper }).bytes,
-                    new long[] { lower }.length
-                ) {
-                    @Override
-                    protected String toString(int dimension, byte[] value) {
-                        return Long.toString(LongPoint.decodeDimension(value, 0));
-                    }
-                }
+                    new long[] { lower }.length,
+                    ApproximatePointRangeQuery.LONG_FORMAT
+                )
             )
 
             ,
@@ -478,11 +444,6 @@ public void testDateRangeQueryTimezone() throws IOException {
         Query parsedQuery = parseQuery(query).toQuery(context);
         assertThat(parsedQuery, instanceOf(DateRangeIncludingNowQuery.class));
         parsedQuery = ((DateRangeIncludingNowQuery) parsedQuery).getQuery();
-        assumeThat(
-            "Using Approximate Range Query as default",
-            FeatureFlags.isEnabled(FeatureFlags.APPROXIMATE_POINT_RANGE_QUERY),
-            is(true)
-        );
         assertThat(parsedQuery, instanceOf(ApproximateScoreQuery.class));
         parsedQuery = ((ApproximateScoreQuery) parsedQuery).getApproximationQuery();
         assertThat(parsedQuery, instanceOf(ApproximateQuery.class));
diff --git a/server/src/test/java/org/opensearch/search/approximate/ApproximatePointRangeQueryTests.java b/server/src/test/java/org/opensearch/search/approximate/ApproximatePointRangeQueryTests.java
index 5d9b523c35f82..4f8bab569db5c 100644
--- a/server/src/test/java/org/opensearch/search/approximate/ApproximatePointRangeQueryTests.java
+++ b/server/src/test/java/org/opensearch/search/approximate/ApproximatePointRangeQueryTests.java
@@ -60,11 +60,13 @@ public void testApproximateRangeEqualsActualRange() throws IOException {
                     try {
                         long lower = RandomNumbers.randomLongBetween(random(), -100, 200);
                         long upper = lower + RandomNumbers.randomLongBetween(random(), 0, 100);
-                        Query approximateQuery = new ApproximatePointRangeQuery("point", pack(lower).bytes, pack(upper).bytes, dims) {
-                            protected String toString(int dimension, byte[] value) {
-                                return Long.toString(LongPoint.decodeDimension(value, 0));
-                            }
-                        };
+                        Query approximateQuery = new ApproximatePointRangeQuery(
+                            "point",
+                            pack(lower).bytes,
+                            pack(upper).bytes,
+                            dims,
+                            ApproximatePointRangeQuery.LONG_FORMAT
+                        );
                         Query query = LongPoint.newRangeQuery("point", lower, upper);
                         IndexSearcher searcher = new IndexSearcher(reader);
                         TopDocs topDocs = searcher.search(approximateQuery, 10);
@@ -100,11 +102,13 @@ public void testApproximateRangeWithDefaultSize() throws IOException {
                     try {
                         long lower = 0;
                         long upper = 1000;
-                        Query approximateQuery = new ApproximatePointRangeQuery("point", pack(lower).bytes, pack(upper).bytes, dims) {
-                            protected String toString(int dimension, byte[] value) {
-                                return Long.toString(LongPoint.decodeDimension(value, 0));
-                            }
-                        };
+                        Query approximateQuery = new ApproximatePointRangeQuery(
+                            "point",
+                            pack(lower).bytes,
+                            pack(upper).bytes,
+                            dims,
+                            ApproximatePointRangeQuery.LONG_FORMAT
+                        );
                         IndexSearcher searcher = new IndexSearcher(reader);
                         TopDocs topDocs = searcher.search(approximateQuery, 10);
                         assertEquals(topDocs.totalHits, new TotalHits(1000, TotalHits.Relation.EQUAL_TO));
@@ -138,11 +142,15 @@ public void testApproximateRangeWithSizeUnderDefault() throws IOException {
                     try {
                         long lower = 0;
                         long upper = 45;
-                        Query approximateQuery = new ApproximatePointRangeQuery("point", pack(lower).bytes, pack(upper).bytes, dims, 10) {
-                            protected String toString(int dimension, byte[] value) {
-                                return Long.toString(LongPoint.decodeDimension(value, 0));
-                            }
-                        };
+                        Query approximateQuery = new ApproximatePointRangeQuery(
+                            "point",
+                            pack(lower).bytes,
+                            pack(upper).bytes,
+                            dims,
+                            10,
+                            null,
+                            ApproximatePointRangeQuery.LONG_FORMAT
+                        );
                         IndexSearcher searcher = new IndexSearcher(reader);
                         TopDocs topDocs = searcher.search(approximateQuery, 10);
                         assertEquals(topDocs.totalHits, new TotalHits(10, TotalHits.Relation.EQUAL_TO));
@@ -182,12 +190,10 @@ public void testApproximateRangeWithSizeOverDefault() throws IOException {
                             pack(lower).bytes,
                             pack(upper).bytes,
                             dims,
-                            11_000
-                        ) {
-                            protected String toString(int dimension, byte[] value) {
-                                return Long.toString(LongPoint.decodeDimension(value, 0));
-                            }
-                        };
+                            11_000,
+                            null,
+                            ApproximatePointRangeQuery.LONG_FORMAT
+                        );
                         IndexSearcher searcher = new IndexSearcher(reader);
                         TopDocs topDocs = searcher.search(approximateQuery, 11000);
 
@@ -228,11 +234,15 @@ public void testApproximateRangeShortCircuit() throws IOException {
                     try {
                         long lower = 0;
                         long upper = 100;
-                        Query approximateQuery = new ApproximatePointRangeQuery("point", pack(lower).bytes, pack(upper).bytes, dims, 10) {
-                            protected String toString(int dimension, byte[] value) {
-                                return Long.toString(LongPoint.decodeDimension(value, 0));
-                            }
-                        };
+                        Query approximateQuery = new ApproximatePointRangeQuery(
+                            "point",
+                            pack(lower).bytes,
+                            pack(upper).bytes,
+                            dims,
+                            10,
+                            null,
+                            ApproximatePointRangeQuery.LONG_FORMAT
+                        );
                         Query query = LongPoint.newRangeQuery("point", lower, upper);
 
                         IndexSearcher searcher = new IndexSearcher(reader);
@@ -278,12 +288,9 @@ public void testApproximateRangeShortCircuitAscSort() throws IOException {
                             pack(upper).bytes,
                             dims,
                             10,
-                            SortOrder.ASC
-                        ) {
-                            protected String toString(int dimension, byte[] value) {
-                                return Long.toString(LongPoint.decodeDimension(value, 0));
-                            }
-                        };
+                            SortOrder.ASC,
+                            ApproximatePointRangeQuery.LONG_FORMAT
+                        );
                         Query query = LongPoint.newRangeQuery("point", lower, upper);
 
                         IndexSearcher searcher = new IndexSearcher(reader);
@@ -312,11 +319,13 @@ protected String toString(int dimension, byte[] value) {
     }
 
     public void testSize() {
-        ApproximatePointRangeQuery query = new ApproximatePointRangeQuery("point", pack(0).bytes, pack(20).bytes, 1) {
-            protected String toString(int dimension, byte[] value) {
-                return Long.toString(LongPoint.decodeDimension(value, 0));
-            }
-        };
+        ApproximatePointRangeQuery query = new ApproximatePointRangeQuery(
+            "point",
+            pack(0).bytes,
+            pack(20).bytes,
+            1,
+            ApproximatePointRangeQuery.LONG_FORMAT
+        );
         assertEquals(query.getSize(), 10_000);
 
         query.setSize(100);
@@ -325,11 +334,13 @@ protected String toString(int dimension, byte[] value) {
     }
 
     public void testSortOrder() {
-        ApproximatePointRangeQuery query = new ApproximatePointRangeQuery("point", pack(0).bytes, pack(20).bytes, 1) {
-            protected String toString(int dimension, byte[] value) {
-                return Long.toString(LongPoint.decodeDimension(value, 0));
-            }
-        };
+        ApproximatePointRangeQuery query = new ApproximatePointRangeQuery(
+            "point",
+            pack(0).bytes,
+            pack(20).bytes,
+            1,
+            ApproximatePointRangeQuery.LONG_FORMAT
+        );
         assertNull(query.getSortOrder());
 
         query.setSortOrder(SortOrder.ASC);
@@ -337,19 +348,23 @@ protected String toString(int dimension, byte[] value) {
     }
 
     public void testCanApproximate() {
-        ApproximatePointRangeQuery query = new ApproximatePointRangeQuery("point", pack(0).bytes, pack(20).bytes, 1) {
-            protected String toString(int dimension, byte[] value) {
-                return Long.toString(LongPoint.decodeDimension(value, 0));
-            }
-        };
+        ApproximatePointRangeQuery query = new ApproximatePointRangeQuery(
+            "point",
+            pack(0).bytes,
+            pack(20).bytes,
+            1,
+            ApproximatePointRangeQuery.LONG_FORMAT
+        );
 
         assertFalse(query.canApproximate(null));
 
-        ApproximatePointRangeQuery queryCanApproximate = new ApproximatePointRangeQuery("point", pack(0).bytes, pack(20).bytes, 1) {
-            protected String toString(int dimension, byte[] value) {
-                return Long.toString(LongPoint.decodeDimension(value, 0));
-            }
-
+        ApproximatePointRangeQuery queryCanApproximate = new ApproximatePointRangeQuery(
+            "point",
+            pack(0).bytes,
+            pack(20).bytes,
+            1,
+            ApproximatePointRangeQuery.LONG_FORMAT
+        ) {
             public boolean canApproximate(SearchContext context) {
                 return true;
             }
diff --git a/server/src/test/java/org/opensearch/search/approximate/ApproximateScoreQueryTests.java b/server/src/test/java/org/opensearch/search/approximate/ApproximateScoreQueryTests.java
index aa45ea6744227..5af49efb30f68 100644
--- a/server/src/test/java/org/opensearch/search/approximate/ApproximateScoreQueryTests.java
+++ b/server/src/test/java/org/opensearch/search/approximate/ApproximateScoreQueryTests.java
@@ -46,12 +46,9 @@ protected String toString(int dimension, byte[] value) {
             "test-index",
             pack(new long[] { l }).bytes,
             pack(new long[] { u }).bytes,
-            new long[] { l }.length
-        ) {
-            protected String toString(int dimension, byte[] value) {
-                return Long.toString(LongPoint.decodeDimension(value, 0));
-            }
-        };
+            new long[] { l }.length,
+            ApproximatePointRangeQuery.LONG_FORMAT
+        );
 
         ApproximateScoreQuery query = new ApproximateScoreQuery(originalQuery, approximateQuery);
         query.resolvedQuery = approximateQuery;


Reviews:
user: login: sandeshkr419
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-04-08T19:59:12Z
user: login: sandeshkr419
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-04-08T20:04:53Z
user: login: msfroh
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-04-08T20:24:19Z
user: login: msfroh
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-04-08T20:24:42Z
user: login: msfroh
state: APPROVED
author_association: CONTRIBUTOR
submitted_at: 2025-04-08T20:24:53Z
user: login: msfroh
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-04-08T20:34:15Z
user: login: sandeshkr419
state: APPROVED
author_association: MEMBER
submitted_at: 2025-04-08T20:52:51Z
user: login: sandeshkr419
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-04-08T21:01:09Z
user: login: msfroh
state: APPROVED
author_association: CONTRIBUTOR
submitted_at: 2025-04-10T00:28:44Z

Review comments:
diff_hunk: @@ -155,6 +158,8 @@ public boolean mightMatchNonNestedDocs(Query query, String nestedPath) {
             return mightMatchNonNestedDocs(((PointRangeQuery) query).getField(), nestedPath);
         } else if (query instanceof IndexOrDocValuesQuery) {
             return mightMatchNonNestedDocs(((IndexOrDocValuesQuery) query).getIndexQuery(), nestedPath);
+        } else if (query instanceof ApproximateScoreQuery) {
path: server/src/main/java/org/opensearch/index/search/NestedHelper.java
user: login: sandeshkr419
body: minor code readability:


```
} else if (query instanceof ApproximateScoreQuery asQuery) {
   return mightMatchNonNestedDocs(asQuery.getOriginalQuery(), nestedPath);
```

This doesn't has any performance benefits so I'll leave it upto you to refactor or not. I just find this more concise and more readable.

In case you are making tis change, make this change for the entire method. 

created_at: 2025-04-08T19:59:12Z
author_association: MEMBER
diff_hunk: @@ -155,6 +158,8 @@ public boolean mightMatchNonNestedDocs(Query query, String nestedPath) {
             return mightMatchNonNestedDocs(((PointRangeQuery) query).getField(), nestedPath);
         } else if (query instanceof IndexOrDocValuesQuery) {
             return mightMatchNonNestedDocs(((IndexOrDocValuesQuery) query).getIndexQuery(), nestedPath);
+        } else if (query instanceof ApproximateScoreQuery) {
+            return mightMatchNonNestedDocs(((ApproximateScoreQuery) query).getOriginalQuery(), nestedPath);
path: server/src/main/java/org/opensearch/index/search/NestedHelper.java
user: login: sandeshkr419
body: Is there a way to decide or improve on which `instanceof` matching should be prioritized over others? Like more common queries should be higher up the matching list over others.

This doesn't has to be part of this change and can be taken as a `TODO` sometime later.
created_at: 2025-04-08T20:04:53Z
author_association: MEMBER
diff_hunk: @@ -155,6 +158,8 @@ public boolean mightMatchNonNestedDocs(Query query, String nestedPath) {
             return mightMatchNonNestedDocs(((PointRangeQuery) query).getField(), nestedPath);
         } else if (query instanceof IndexOrDocValuesQuery) {
             return mightMatchNonNestedDocs(((IndexOrDocValuesQuery) query).getIndexQuery(), nestedPath);
+        } else if (query instanceof ApproximateScoreQuery) {
path: server/src/main/java/org/opensearch/index/search/NestedHelper.java
user: login: msfroh
body: Actually, we can make it a `switch` statement: https://docs.oracle.com/en/java/javase/17/language/pattern-matching-switch.html
created_at: 2025-04-08T20:22:16Z
author_association: CONTRIBUTOR
diff_hunk: @@ -155,6 +158,8 @@ public boolean mightMatchNonNestedDocs(Query query, String nestedPath) {
             return mightMatchNonNestedDocs(((PointRangeQuery) query).getField(), nestedPath);
         } else if (query instanceof IndexOrDocValuesQuery) {
             return mightMatchNonNestedDocs(((IndexOrDocValuesQuery) query).getIndexQuery(), nestedPath);
+        } else if (query instanceof ApproximateScoreQuery) {
path: server/src/main/java/org/opensearch/index/search/NestedHelper.java
user: login: msfroh
body: I think we should do this in a follow-up PR, though.
created_at: 2025-04-08T20:24:42Z
author_association: CONTRIBUTOR
diff_hunk: @@ -155,6 +158,8 @@ public boolean mightMatchNonNestedDocs(Query query, String nestedPath) {
             return mightMatchNonNestedDocs(((PointRangeQuery) query).getField(), nestedPath);
         } else if (query instanceof IndexOrDocValuesQuery) {
             return mightMatchNonNestedDocs(((IndexOrDocValuesQuery) query).getIndexQuery(), nestedPath);
+        } else if (query instanceof ApproximateScoreQuery) {
path: server/src/main/java/org/opensearch/index/search/NestedHelper.java
user: login: msfroh
body: Incidentally, I was able (as a proof-of-concept) to rewrite this method as:

```
    public boolean mightMatchNestedDocs(Query query) {
        return switch (query) {
            case ConstantScoreQuery csq -> mightMatchNestedDocs(csq.getQuery());
            case BoostQuery bq -> mightMatchNestedDocs(bq.getQuery());
            case MatchAllDocsQuery ignored -> true;
            case MatchNoDocsQuery ignored -> false;
            case TermQuery tq -> mightMatchNestedDocs(tq.getTerm().field());
            case TermInSetQuery tisq -> tisq.getTermsCount() > 0 && mightMatchNestedDocs(tisq.getField());
            case PointRangeQuery prq -> mightMatchNestedDocs(prq.getField());
            case IndexOrDocValuesQuery iodvq -> mightMatchNestedDocs(iodvq.getIndexQuery());
            case BooleanQuery bq -> mightMatchNestedDocs(bq);
            case OpenSearchToParentBlockJoinQuery ostpbjq -> ostpbjq.getPath() != null;
            default -> true;
        };
    }
```
created_at: 2025-04-08T20:34:15Z
author_association: CONTRIBUTOR
diff_hunk: @@ -155,6 +158,8 @@ public boolean mightMatchNonNestedDocs(Query query, String nestedPath) {
             return mightMatchNonNestedDocs(((PointRangeQuery) query).getField(), nestedPath);
         } else if (query instanceof IndexOrDocValuesQuery) {
             return mightMatchNonNestedDocs(((IndexOrDocValuesQuery) query).getIndexQuery(), nestedPath);
+        } else if (query instanceof ApproximateScoreQuery) {
path: server/src/main/java/org/opensearch/index/search/NestedHelper.java
user: login: sandeshkr419
body: Thanks @msfroh for the POC. This certainly makes the code a lot more readable.

> I think we should do this in a follow-up PR, though.

Sounds good. 
@harshavamsi Lets just make a code refactoring issue with `good first issue` label in-case you yourself are not making a follow-up PR for this. We can even scope this up to do a check on other places where such refactoring might help. 
created_at: 2025-04-08T21:01:09Z
author_association: MEMBER

PR comments:
user: login: harshavamsi
created_at: 2025-04-03T00:58:29Z
body: run-benchmark-test: id_4
author_association: CONTRIBUTOR
user: login: github-actions[bot]
created_at: 2025-04-03T01:09:09Z
body: :x: Gradle check result for 0ca7a6b66a56d3132f6653aba00762772b67bf49: [FAILURE](https://build.ci.opensearch.org/job/gradle-check/55437/)

Please examine the workflow log, locate, and copy-paste the failure(s) below, then iterate to green. Is the failure [a flaky test](https://github.com/opensearch-project/OpenSearch/blob/main/DEVELOPER_GUIDE.md#flaky-tests) unrelated to your change?
author_association: CONTRIBUTOR
user: login: github-actions[bot]
created_at: 2025-04-03T01:57:09Z
body: :x: Gradle check result for 9388c6393e84d38d332b2dba8d10080e5596d1c6: [FAILURE](https://build.ci.opensearch.org/job/gradle-check/55438/)

Please examine the workflow log, locate, and copy-paste the failure(s) below, then iterate to green. Is the failure [a flaky test](https://github.com/opensearch-project/OpenSearch/blob/main/DEVELOPER_GUIDE.md#flaky-tests) unrelated to your change?
author_association: CONTRIBUTOR
user: login: github-actions[bot]
created_at: 2025-04-03T03:25:41Z
body: :white_check_mark: Gradle check result for 09dbaf77148f73630336570327520a141f53674a: [SUCCESS](https://build.ci.opensearch.org/job/gradle-check/55445/)
author_association: CONTRIBUTOR
user: login: codecov[bot]
created_at: 2025-04-03T03:26:06Z
body: ## [Codecov](https://app.codecov.io/gh/opensearch-project/OpenSearch/pull/17769?dropdown=coverage&src=pr&el=h1&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=opensearch-project) Report
Attention: Patch coverage is `73.91304%` with `12 lines` in your changes missing coverage. Please review.
> Project coverage is 72.33%. Comparing base [(`7b6108b`)](https://app.codecov.io/gh/opensearch-project/OpenSearch/commit/7b6108bcf47fe2a3c75af9d7a1adb29a9c04938c?dropdown=coverage&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=opensearch-project) to head [(`831376c`)](https://app.codecov.io/gh/opensearch-project/OpenSearch/commit/831376c709b5b622d69f1c133dc2a7d4a439b3a6?dropdown=coverage&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=opensearch-project).
> Report is 13 commits behind head on main.

| [Files with missing lines](https://app.codecov.io/gh/opensearch-project/OpenSearch/pull/17769?dropdown=coverage&src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=opensearch-project) | Patch % | Lines |
|---|---|---|
| [...search/approximate/ApproximatePointRangeQuery.java](https://app.codecov.io/gh/opensearch-project/OpenSearch/pull/17769?src=pr&el=tree&filepath=server%2Fsrc%2Fmain%2Fjava%2Forg%2Fopensearch%2Fsearch%2Fapproximate%2FApproximatePointRangeQuery.java&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=opensearch-project#diff-c2VydmVyL3NyYy9tYWluL2phdmEvb3JnL29wZW5zZWFyY2gvc2VhcmNoL2FwcHJveGltYXRlL0FwcHJveGltYXRlUG9pbnRSYW5nZVF1ZXJ5LmphdmE=) | 57.89% | [7 Missing and 1 partial :warning: ](https://app.codecov.io/gh/opensearch-project/OpenSearch/pull/17769?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=opensearch-project) |
| [...org/opensearch/index/mapper/NumberFieldMapper.java](https://app.codecov.io/gh/opensearch-project/OpenSearch/pull/17769?src=pr&el=tree&filepath=server%2Fsrc%2Fmain%2Fjava%2Forg%2Fopensearch%2Findex%2Fmapper%2FNumberFieldMapper.java&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=opensearch-project#diff-c2VydmVyL3NyYy9tYWluL2phdmEvb3JnL29wZW5zZWFyY2gvaW5kZXgvbWFwcGVyL051bWJlckZpZWxkTWFwcGVyLmphdmE=) | 73.33% | [3 Missing and 1 partial :warning: ](https://app.codecov.io/gh/opensearch-project/OpenSearch/pull/17769?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=opensearch-project) |

<details><summary>Additional details and impacted files</summary>


```diff
@@             Coverage Diff              @@
##               main   #17769      +/-   ##
============================================
- Coverage     72.44%   72.33%   -0.12%     
+ Complexity    66483    66391      -92     
============================================
  Files          5409     5409              
  Lines        308282   308267      -15     
  Branches      44759    44754       -5     
============================================
- Hits         223344   222979     -365     
- Misses        66608    67044     +436     
+ Partials      18330    18244      -86     
```

</details>

[:umbrella: View full report in Codecov by Sentry](https://app.codecov.io/gh/opensearch-project/OpenSearch/pull/17769?dropdown=coverage&src=pr&el=continue&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=opensearch-project).   
:loudspeaker: Have feedback on the report? [Share it here](https://about.codecov.io/codecov-pr-comment-feedback/?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=opensearch-project).

<details><summary> :rocket: New features to boost your workflow: </summary>

- :snowflake: [Test Analytics](https://docs.codecov.com/docs/test-analytics): Detect flaky tests, report on failures, and find test suite problems.
</details>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-04-03T03:32:17Z
body: The Jenkins job url is https://build.ci.opensearch.org/job/benchmark-pull-request/2754/ . Final results will be published once the job is completed.
author_association: CONTRIBUTOR
user: login: opensearch-ci-bot
created_at: 2025-04-03T08:22:06Z
body: <details><summary>Benchmark Results</summary>

#### Benchmark Results for Job: https://build.ci.opensearch.org/job/benchmark-pull-request/2754/
|                                                         Metric |                                                 Task |       Value |    Unit |
|---------------------------------------------------------------:|-----------------------------------------------------:|------------:|--------:|
|                     Cumulative indexing time of primary shards |                                                      |           0 |     min |
|             Min cumulative indexing time across primary shards |                                                      |           0 |     min |
|          Median cumulative indexing time across primary shards |                                                      |           0 |     min |
|             Max cumulative indexing time across primary shards |                                                      |           0 |     min |
|            Cumulative indexing throttle time of primary shards |                                                      |           0 |     min |
|    Min cumulative indexing throttle time across primary shards |                                                      |           0 |     min |
| Median cumulative indexing throttle time across primary shards |                                                      |           0 |     min |
|    Max cumulative indexing throttle time across primary shards |                                                      |           0 |     min |
|                        Cumulative merge time of primary shards |                                                      |           0 |     min |
|                       Cumulative merge count of primary shards |                                                      |           0 |         |
|                Min cumulative merge time across primary shards |                                                      |           0 |     min |
|             Median cumulative merge time across primary shards |                                                      |           0 |     min |
|                Max cumulative merge time across primary shards |                                                      |           0 |     min |
|               Cumulative merge throttle time of primary shards |                                                      |           0 |     min |
|       Min cumulative merge throttle time across primary shards |                                                      |           0 |     min |
|    Median cumulative merge throttle time across primary shards |                                                      |           0 |     min |
|       Max cumulative merge throttle time across primary shards |                                                      |           0 |     min |
|                      Cumulative refresh time of primary shards |                                                      |           0 |     min |
|                     Cumulative refresh count of primary shards |                                                      |           4 |         |
|              Min cumulative refresh time across primary shards |                                                      |           0 |     min |
|           Median cumulative refresh time across primary shards |                                                      |           0 |     min |
|              Max cumulative refresh time across primary shards |                                                      |           0 |     min |
|                        Cumulative flush time of primary shards |                                                      |           0 |     min |
|                       Cumulative flush count of primary shards |                                                      |           1 |         |
|                Min cumulative flush time across primary shards |                                                      |           0 |     min |
|             Median cumulative flush time across primary shards |                                                      |           0 |     min |
|                Max cumulative flush time across primary shards |                                                      |           0 |     min |
|                                        Total Young Gen GC time |                                                      |       1.613 |       s |
|                                       Total Young Gen GC count |                                                      |          53 |         |
|                                          Total Old Gen GC time |                                                      |           0 |       s |
|                                         Total Old Gen GC count |                                                      |           0 |         |
|                                                     Store size |                                                      |     22.1906 |      GB |
|                                                  Translog size |                                                      | 5.12227e-08 |      GB |
|                                         Heap used for segments |                                                      |           0 |      MB |
|                                       Heap used for doc values |                                                      |           0 |      MB |
|                                            Heap used for terms |                                                      |           0 |      MB |
|                                            Heap used for norms |                                                      |           0 |      MB |
|                                           Heap used for points |                                                      |           0 |      MB |
|                                    Heap used for stored fields |                                                      |           0 |      MB |
|                                                  Segment count |                                                      |          10 |         |
|                                                 Min Throughput |                           wait-for-snapshot-recovery | 4.18059e+07 |  byte/s |
|                                                Mean Throughput |                           wait-for-snapshot-recovery | 4.18059e+07 |  byte/s |
|                                              Median Throughput |                           wait-for-snapshot-recovery | 4.18059e+07 |  byte/s |
|                                                 Max Throughput |                           wait-for-snapshot-recovery | 4.18059e+07 |  byte/s |
|                                       100th percentile latency |                           wait-for-snapshot-recovery |      564521 |      ms |
|                                  100th percentile service time |                           wait-for-snapshot-recovery |      564521 |      ms |
|                                                     error rate |                           wait-for-snapshot-recovery |           0 |       % |
|                                                 Min Throughput |                             wait-until-merges-finish |      105.11 |   ops/s |
|                                                Mean Throughput |                             wait-until-merges-finish |      105.11 |   ops/s |
|                                              Median Throughput |                             wait-until-merges-finish |      105.11 |   ops/s |
|                                                 Max Throughput |                             wait-until-merges-finish |      105.11 |   ops/s |
|                                       100th percentile latency |                             wait-until-merges-finish |      9.2149 |      ms |
|                                  100th percentile service time |                             wait-until-merges-finish |      9.2149 |      ms |
|                                                     error rate |                             wait-until-merges-finish |           0 |       % |
|                                                 Min Throughput |                                              default |        2.01 |   ops/s |
|                                                Mean Throughput |                                              default |        2.01 |   ops/s |
|                                              Median Throughput |                                              default |        2.01 |   ops/s |
|                                                 Max Throughput |                                              default |        2.01 |   ops/s |
|                                        50th percentile latency |                                              default |     6.83109 |      ms |
|                                        90th percentile latency |                                              default |     7.28712 |      ms |
|                                        99th percentile latency |                                              default |     8.02337 |      ms |
|                                       100th percentile latency |                                              default |     8.03111 |      ms |
|                                   50th percentile service time |                                              default |     5.52838 |      ms |
|                                   90th percentile service time |                                              default |     5.98272 |      ms |
|                                   99th percentile service time |                                              default |     6.51492 |      ms |
|                                  100th percentile service time |                                              default |     6.55637 |      ms |
|                                                     error rate |                                              default |           0 |       % |
|                                                 Min Throughput |                                  desc_sort_timestamp |        2.01 |   ops/s |
|                                                Mean Throughput |                                  desc_sort_timestamp |        2.01 |   ops/s |
|                                              Median Throughput |                                  desc_sort_timestamp |        2.01 |   ops/s |
|                                                 Max Throughput |                                  desc_sort_timestamp |        2.01 |   ops/s |
|                                        50th percentile latency |                                  desc_sort_timestamp |     7.57753 |      ms |
|                                        90th percentile latency |                                  desc_sort_timestamp |     8.12121 |      ms |
|                                        99th percentile latency |                                  desc_sort_timestamp |     9.67222 |      ms |
|                                       100th percentile latency |                                  desc_sort_timestamp |     10.1711 |      ms |
|                                   50th percentile service time |                                  desc_sort_timestamp |      6.1954 |      ms |
|                                   90th percentile service time |                                  desc_sort_timestamp |     6.79498 |      ms |
|                                   99th percentile service time |                                  desc_sort_timestamp |     8.07599 |      ms |
|                                  100th percentile service time |                                  desc_sort_timestamp |     8.51967 |      ms |
|                                                     error rate |                                  desc_sort_timestamp |           0 |       % |
|                                                 Min Throughput |                                   asc_sort_timestamp |        2.01 |   ops/s |
|                                                Mean Throughput |                                   asc_sort_timestamp |        2.01 |   ops/s |
|                                              Median Throughput |                                   asc_sort_timestamp |        2.01 |   ops/s |
|                                                 Max Throughput |                                   asc_sort_timestamp |        2.01 |   ops/s |
|                                        50th percentile latency |                                   asc_sort_timestamp |     9.35412 |      ms |
|                                        90th percentile latency |                                   asc_sort_timestamp |     9.78918 |      ms |
|                                        99th percentile latency |                                   asc_sort_timestamp |     11.7457 |      ms |
|                                       100th percentile latency |                                   asc_sort_timestamp |     12.2157 |      ms |
|                                   50th percentile service time |                                   asc_sort_timestamp |     7.98773 |      ms |
|                                   90th percentile service time |                                   asc_sort_timestamp |     8.23209 |      ms |
|                                   99th percentile service time |                                   asc_sort_timestamp |     10.7044 |      ms |
|                                  100th percentile service time |                                   asc_sort_timestamp |     11.0681 |      ms |
|                                                     error rate |                                   asc_sort_timestamp |           0 |       % |
|                                                 Min Throughput |                       desc_sort_with_after_timestamp |           2 |   ops/s |
|                                                Mean Throughput |                       desc_sort_with_after_timestamp |           2 |   ops/s |
|                                              Median Throughput |                       desc_sort_with_after_timestamp |           2 |   ops/s |
|                                                 Max Throughput |                       desc_sort_with_after_timestamp |           2 |   ops/s |
|                                        50th percentile latency |                       desc_sort_with_after_timestamp |     113.459 |      ms |
|                                        90th percentile latency |                       desc_sort_with_after_timestamp |     115.679 |      ms |
|                                        99th percentile latency |                       desc_sort_with_after_timestamp |     127.268 |      ms |
|                                       100th percentile latency |                       desc_sort_with_after_timestamp |     128.152 |      ms |
|                                   50th percentile service time |                       desc_sort_with_after_timestamp |     112.321 |      ms |
|                                   90th percentile service time |                       desc_sort_with_after_timestamp |     114.465 |      ms |
|                                   99th percentile service time |                       desc_sort_with_after_timestamp |     126.004 |      ms |
|                                  100th percentile service time |                       desc_sort_with_after_timestamp |     127.054 |      ms |
|                                                     error rate |                       desc_sort_with_after_timestamp |           0 |       % |
|                                                 Min Throughput |                        asc_sort_with_after_timestamp |           2 |   ops/s |
|                                                Mean Throughput |                        asc_sort_with_after_timestamp |           2 |   ops/s |
|                                              Median Throughput |                        asc_sort_with_after_timestamp |           2 |   ops/s |
|                                                 Max Throughput |                        asc_sort_with_after_timestamp |        2.01 |   ops/s |
|                                        50th percentile latency |                        asc_sort_with_after_timestamp |     216.204 |      ms |
|                                        90th percentile latency |                        asc_sort_with_after_timestamp |     219.289 |      ms |
|                                        99th percentile latency |                        asc_sort_with_after_timestamp |     246.476 |      ms |
|                                       100th percentile latency |                        asc_sort_with_after_timestamp |     250.726 |      ms |
|                                   50th percentile service time |                        asc_sort_with_after_timestamp |     214.402 |      ms |
|                                   90th percentile service time |                        asc_sort_with_after_timestamp |     217.462 |      ms |
|                                   99th percentile service time |                        asc_sort_with_after_timestamp |     244.276 |      ms |
|                                  100th percentile service time |                        asc_sort_with_after_timestamp |     248.306 |      ms |
|                                                     error rate |                        asc_sort_with_after_timestamp |           0 |       % |
|                                                 Min Throughput |               desc_sort_timestamp_can_match_shortcut |        2.01 |   ops/s |
|                                                Mean Throughput |               desc_sort_timestamp_can_match_shortcut |        2.01 |   ops/s |
|                                              Median Throughput |               desc_sort_timestamp_can_match_shortcut |        2.01 |   ops/s |
|                                                 Max Throughput |               desc_sort_timestamp_can_match_shortcut |        2.01 |   ops/s |
|                                        50th percentile latency |               desc_sort_timestamp_can_match_shortcut |     7.42587 |      ms |
|                                        90th percentile latency |               desc_sort_timestamp_can_match_shortcut |     7.80999 |      ms |
|                                        99th percentile latency |               desc_sort_timestamp_can_match_shortcut |      9.1266 |      ms |
|                                       100th percentile latency |               desc_sort_timestamp_can_match_shortcut |      9.5246 |      ms |
|                                   50th percentile service time |               desc_sort_timestamp_can_match_shortcut |     6.04727 |      ms |
|                                   90th percentile service time |               desc_sort_timestamp_can_match_shortcut |     6.23341 |      ms |
|                                   99th percentile service time |               desc_sort_timestamp_can_match_shortcut |     7.63512 |      ms |
|                                  100th percentile service time |               desc_sort_timestamp_can_match_shortcut |     7.93663 |      ms |
|                                                     error rate |               desc_sort_timestamp_can_match_shortcut |           0 |       % |
|                                                 Min Throughput |            desc_sort_timestamp_no_can_match_shortcut |        2.01 |   ops/s |
|                                                Mean Throughput |            desc_sort_timestamp_no_can_match_shortcut |        2.01 |   ops/s |
|                                              Median Throughput |            desc_sort_timestamp_no_can_match_shortcut |        2.01 |   ops/s |
|                                                 Max Throughput |            desc_sort_timestamp_no_can_match_shortcut |        2.01 |   ops/s |
|                                        50th percentile latency |            desc_sort_timestamp_no_can_match_shortcut |      6.7835 |      ms |
|                                        90th percentile latency |            desc_sort_timestamp_no_can_match_shortcut |     7.22356 |      ms |
|                                        99th percentile latency |            desc_sort_timestamp_no_can_match_shortcut |      8.1375 |      ms |
|                                       100th percentile latency |            desc_sort_timestamp_no_can_match_shortcut |     8.15911 |      ms |
|                                   50th percentile service time |            desc_sort_timestamp_no_can_match_shortcut |     5.43074 |      ms |
|                                   90th percentile service time |            desc_sort_timestamp_no_can_match_shortcut |     5.57684 |      ms |
|                                   99th percentile service time |            desc_sort_timestamp_no_can_match_shortcut |     6.49646 |      ms |
|                                  100th percentile service time |            desc_sort_timestamp_no_can_match_shortcut |     6.63679 |      ms |
|                                                     error rate |            desc_sort_timestamp_no_can_match_shortcut |           0 |       % |
|                                                 Min Throughput |                asc_sort_timestamp_can_match_shortcut |        2.01 |   ops/s |
|                                                Mean Throughput |                asc_sort_timestamp_can_match_shortcut |        2.01 |   ops/s |
|                                              Median Throughput |                asc_sort_timestamp_can_match_shortcut |        2.01 |   ops/s |
|                                                 Max Throughput |                asc_sort_timestamp_can_match_shortcut |        2.01 |   ops/s |
|                                        50th percentile latency |                asc_sort_timestamp_can_match_shortcut |     8.67356 |      ms |
|                                        90th percentile latency |                asc_sort_timestamp_can_match_shortcut |      9.1211 |      ms |
|                                        99th percentile latency |                asc_sort_timestamp_can_match_shortcut |     10.1767 |      ms |
|                                       100th percentile latency |                asc_sort_timestamp_can_match_shortcut |     11.0151 |      ms |
|                                   50th percentile service time |                asc_sort_timestamp_can_match_shortcut |     7.39599 |      ms |
|                                   90th percentile service time |                asc_sort_timestamp_can_match_shortcut |     7.49423 |      ms |
|                                   99th percentile service time |                asc_sort_timestamp_can_match_shortcut |     8.74856 |      ms |
|                                  100th percentile service time |                asc_sort_timestamp_can_match_shortcut |     9.73906 |      ms |
|                                                     error rate |                asc_sort_timestamp_can_match_shortcut |           0 |       % |
|                                                 Min Throughput |             asc_sort_timestamp_no_can_match_shortcut |        2.01 |   ops/s |
|                                                Mean Throughput |             asc_sort_timestamp_no_can_match_shortcut |        2.01 |   ops/s |
|                                              Median Throughput |             asc_sort_timestamp_no_can_match_shortcut |        2.01 |   ops/s |
|                                                 Max Throughput |             asc_sort_timestamp_no_can_match_shortcut |        2.01 |   ops/s |
|                                        50th percentile latency |             asc_sort_timestamp_no_can_match_shortcut |     8.76229 |      ms |
|                                        90th percentile latency |             asc_sort_timestamp_no_can_match_shortcut |     9.18949 |      ms |
|                                        99th percentile latency |             asc_sort_timestamp_no_can_match_shortcut |     10.2762 |      ms |
|                                       100th percentile latency |             asc_sort_timestamp_no_can_match_shortcut |     11.1207 |      ms |
|                                   50th percentile service time |             asc_sort_timestamp_no_can_match_shortcut |     7.39028 |      ms |
|                                   90th percentile service time |             asc_sort_timestamp_no_can_match_shortcut |      7.5843 |      ms |
|                                   99th percentile service time |             asc_sort_timestamp_no_can_match_shortcut |     9.07068 |      ms |
|                                  100th percentile service time |             asc_sort_timestamp_no_can_match_shortcut |     9.77161 |      ms |
|                                                     error rate |             asc_sort_timestamp_no_can_match_shortcut |           0 |       % |
|                                                 Min Throughput |                                                 term |        2.01 |   ops/s |
|                                                Mean Throughput |                                                 term |        2.01 |   ops/s |
|                                              Median Throughput |                                                 term |        2.01 |   ops/s |
|                                                 Max Throughput |                                                 term |        2.01 |   ops/s |
|                                        50th percentile latency |                                                 term |      6.3658 |      ms |
|                                        90th percentile latency |                                                 term |     6.76335 |      ms |
|                                        99th percentile latency |                                                 term |     7.84978 |      ms |
|                                       100th percentile latency |                                                 term |     8.24088 |      ms |
|                                   50th percentile service time |                                                 term |     4.93637 |      ms |
|                                   90th percentile service time |                                                 term |     5.12414 |      ms |
|                                   99th percentile service time |                                                 term |     6.00565 |      ms |
|                                  100th percentile service time |                                                 term |     6.02292 |      ms |
|                                                     error rate |                                                 term |           0 |       % |
|                                                 Min Throughput |                                  multi_terms-keyword |        1.12 |   ops/s |
|                                                Mean Throughput |                                  multi_terms-keyword |        1.12 |   ops/s |
|                                              Median Throughput |                                  multi_terms-keyword |        1.12 |   ops/s |
|                                                 Max Throughput |                                  multi_terms-keyword |        1.12 |   ops/s |
|                                        50th percentile latency |                                  multi_terms-keyword |     98999.8 |      ms |
|                                        90th percentile latency |                                  multi_terms-keyword |      114570 |      ms |
|                                        99th percentile latency |                                  multi_terms-keyword |      118058 |      ms |
|                                       100th percentile latency |                                  multi_terms-keyword |      118254 |      ms |
|                                   50th percentile service time |                                  multi_terms-keyword |     888.132 |      ms |
|                                   90th percentile service time |                                  multi_terms-keyword |     892.766 |      ms |
|                                   99th percentile service time |                                  multi_terms-keyword |     905.574 |      ms |
|                                  100th percentile service time |                                  multi_terms-keyword |     905.593 |      ms |
|                                                     error rate |                                  multi_terms-keyword |           0 |       % |
|                                                 Min Throughput |                                        keyword-terms |           2 |   ops/s |
|                                                Mean Throughput |                                        keyword-terms |        2.01 |   ops/s |
|                                              Median Throughput |                                        keyword-terms |        2.01 |   ops/s |
|                                                 Max Throughput |                                        keyword-terms |        2.01 |   ops/s |
|                                        50th percentile latency |                                        keyword-terms |     42.4174 |      ms |
|                                        90th percentile latency |                                        keyword-terms |     42.9069 |      ms |
|                                        99th percentile latency |                                        keyword-terms |     43.4413 |      ms |
|                                       100th percentile latency |                                        keyword-terms |     43.5151 |      ms |
|                                   50th percentile service time |                                        keyword-terms |     41.0794 |      ms |
|                                   90th percentile service time |                                        keyword-terms |     41.3704 |      ms |
|                                   99th percentile service time |                                        keyword-terms |     42.1752 |      ms |
|                                  100th percentile service time |                                        keyword-terms |     42.2269 |      ms |
|                                                     error rate |                                        keyword-terms |           0 |       % |
|                                                 Min Throughput |                        keyword-terms-low-cardinality |        2.01 |   ops/s |
|                                                Mean Throughput |                        keyword-terms-low-cardinality |        2.01 |   ops/s |
|                                              Median Throughput |                        keyword-terms-low-cardinality |        2.01 |   ops/s |
|                                                 Max Throughput |                        keyword-terms-low-cardinality |        2.01 |   ops/s |
|                                        50th percentile latency |                        keyword-terms-low-cardinality |     36.7567 |      ms |
|                                        90th percentile latency |                        keyword-terms-low-cardinality |      37.261 |      ms |
|                                        99th percentile latency |                        keyword-terms-low-cardinality |     39.1844 |      ms |
|                                       100th percentile latency |                        keyword-terms-low-cardinality |     39.5664 |      ms |
|                                   50th percentile service time |                        keyword-terms-low-cardinality |     35.5911 |      ms |
|                                   90th percentile service time |                        keyword-terms-low-cardinality |     35.8307 |      ms |
|                                   99th percentile service time |                        keyword-terms-low-cardinality |     37.5805 |      ms |
|                                  100th percentile service time |                        keyword-terms-low-cardinality |      38.089 |      ms |
|                                                     error rate |                        keyword-terms-low-cardinality |           0 |       % |
|                                                 Min Throughput |                                      composite-terms |           2 |   ops/s |
|                                                Mean Throughput |                                      composite-terms |           2 |   ops/s |
|                                              Median Throughput |                                      composite-terms |           2 |   ops/s |
|                                                 Max Throughput |                                      composite-terms |           2 |   ops/s |
|                                        50th percentile latency |                                      composite-terms |      235.31 |      ms |
|                                        90th percentile latency |                                      composite-terms |     238.882 |      ms |
|                                        99th percentile latency |                                      composite-terms |     247.514 |      ms |
|                                       100th percentile latency |                                      composite-terms |     253.864 |      ms |
|                                   50th percentile service time |                                      composite-terms |     234.216 |      ms |
|                                   90th percentile service time |                                      composite-terms |     237.571 |      ms |
|                                   99th percentile service time |                                      composite-terms |      246.27 |      ms |
|                                  100th percentile service time |                                      composite-terms |     252.555 |      ms |
|                                                     error rate |                                      composite-terms |           0 |       % |
|                                                 Min Throughput |                              composite_terms-keyword |           2 |   ops/s |
|                                                Mean Throughput |                              composite_terms-keyword |           2 |   ops/s |
|                                              Median Throughput |                              composite_terms-keyword |           2 |   ops/s |
|                                                 Max Throughput |                              composite_terms-keyword |           2 |   ops/s |
|                                        50th percentile latency |                              composite_terms-keyword |     375.104 |      ms |
|                                        90th percentile latency |                              composite_terms-keyword |     380.232 |      ms |
|                                        99th percentile latency |                              composite_terms-keyword |     388.553 |      ms |
|                                       100th percentile latency |                              composite_terms-keyword |     390.019 |      ms |
|                                   50th percentile service time |                              composite_terms-keyword |     374.088 |      ms |
|                                   90th percentile service time |                              composite_terms-keyword |     379.365 |      ms |
|                                   99th percentile service time |                              composite_terms-keyword |     387.473 |      ms |
|                                  100th percentile service time |                              composite_terms-keyword |     388.882 |      ms |
|                                                     error rate |                              composite_terms-keyword |           0 |       % |
|                                                 Min Throughput |                       composite-date_histogram-daily |        2.01 |   ops/s |
|                                                Mean Throughput |                       composite-date_histogram-daily |        2.01 |   ops/s |
|                                              Median Throughput |                       composite-date_histogram-daily |        2.01 |   ops/s |
|                                                 Max Throughput |                       composite-date_histogram-daily |        2.01 |   ops/s |
|                                        50th percentile latency |                       composite-date_histogram-daily |     4.26405 |      ms |
|                                        90th percentile latency |                       composite-date_histogram-daily |     4.59133 |      ms |
|                                        99th percentile latency |                       composite-date_histogram-daily |     4.74651 |      ms |
|                                       100th percentile latency |                       composite-date_histogram-daily |     4.77101 |      ms |
|                                   50th percentile service time |                       composite-date_histogram-daily |     2.97162 |      ms |
|                                   90th percentile service time |                       composite-date_histogram-daily |     3.10899 |      ms |
|                                   99th percentile service time |                       composite-date_histogram-daily |     3.37912 |      ms |
|                                  100th percentile service time |                       composite-date_histogram-daily |     3.39086 |      ms |
|                                                     error rate |                       composite-date_histogram-daily |           0 |       % |
|                                                 Min Throughput |                                                range |        2.01 |   ops/s |
|                                                Mean Throughput |                                                range |        2.01 |   ops/s |
|                                              Median Throughput |                                                range |        2.01 |   ops/s |
|                                                 Max Throughput |                                                range |        2.01 |   ops/s |
|                                        50th percentile latency |                                                range |     5.69891 |      ms |
|                                        90th percentile latency |                                                range |     6.13063 |      ms |
|                                        99th percentile latency |                                                range |     6.23498 |      ms |
|                                       100th percentile latency |                                                range |     6.24981 |      ms |
|                                   50th percentile service time |                                                range |     4.43809 |      ms |
|                                   90th percentile service time |                                                range |     4.50149 |      ms |
|                                   99th percentile service time |                                                range |     4.56258 |      ms |
|                                  100th percentile service time |                                                range |     4.56739 |      ms |
|                                                     error rate |                                                range |           0 |       % |
|                                                 Min Throughput |                                        range-numeric |        2.01 |   ops/s |
|                                                Mean Throughput |                                        range-numeric |        2.01 |   ops/s |
|                                              Median Throughput |                                        range-numeric |        2.01 |   ops/s |
|                                                 Max Throughput |                                        range-numeric |        2.01 |   ops/s |
|                                        50th percentile latency |                                        range-numeric |      3.8819 |      ms |
|                                        90th percentile latency |                                        range-numeric |      4.2958 |      ms |
|                                        99th percentile latency |                                        range-numeric |     4.56464 |      ms |
|                                       100th percentile latency |                                        range-numeric |      4.6401 |      ms |
|                                   50th percentile service time |                                        range-numeric |     2.59677 |      ms |
|                                   90th percentile service time |                                        range-numeric |     2.69996 |      ms |
|                                   99th percentile service time |                                        range-numeric |     2.88843 |      ms |
|                                  100th percentile service time |                                        range-numeric |     2.90659 |      ms |
|                                                     error rate |                                        range-numeric |           0 |       % |
|                                                 Min Throughput |                                     keyword-in-range |           2 |   ops/s |
|                                                Mean Throughput |                                     keyword-in-range |        2.01 |   ops/s |
|                                              Median Throughput |                                     keyword-in-range |           2 |   ops/s |
|                                                 Max Throughput |                                     keyword-in-range |        2.01 |   ops/s |
|                                        50th percentile latency |                                     keyword-in-range |     58.3714 |      ms |
|                                        90th percentile latency |                                     keyword-in-range |     59.2045 |      ms |
|                                        99th percentile latency |                                     keyword-in-range |     61.6306 |      ms |
|                                       100th percentile latency |                                     keyword-in-range |     63.1732 |      ms |
|                                   50th percentile service time |                                     keyword-in-range |     57.1088 |      ms |
|                                   90th percentile service time |                                     keyword-in-range |      57.874 |      ms |
|                                   99th percentile service time |                                     keyword-in-range |     60.4081 |      ms |
|                                  100th percentile service time |                                     keyword-in-range |     62.0774 |      ms |
|                                                     error rate |                                     keyword-in-range |           0 |       % |
|                                                 Min Throughput |                            date_histogram_hourly_agg |        2.01 |   ops/s |
|                                                Mean Throughput |                            date_histogram_hourly_agg |        2.01 |   ops/s |
|                                              Median Throughput |                            date_histogram_hourly_agg |        2.01 |   ops/s |
|                                                 Max Throughput |                            date_histogram_hourly_agg |        2.01 |   ops/s |
|                                        50th percentile latency |                            date_histogram_hourly_agg |     8.44707 |      ms |
|                                        90th percentile latency |                            date_histogram_hourly_agg |      8.8692 |      ms |
|                                        99th percentile latency |                            date_histogram_hourly_agg |     9.35257 |      ms |
|                                       100th percentile latency |                            date_histogram_hourly_agg |     9.35772 |      ms |
|                                   50th percentile service time |                            date_histogram_hourly_agg |     7.14251 |      ms |
|                                   90th percentile service time |                            date_histogram_hourly_agg |     7.29874 |      ms |
|                                   99th percentile service time |                            date_histogram_hourly_agg |     7.66091 |      ms |
|                                  100th percentile service time |                            date_histogram_hourly_agg |     7.68337 |      ms |
|                                                     error rate |                            date_histogram_hourly_agg |           0 |       % |
|                                                 Min Throughput |                            date_histogram_minute_agg |        2.01 |   ops/s |
|                                                Mean Throughput |                            date_histogram_minute_agg |        2.01 |   ops/s |
|                                              Median Throughput |                            date_histogram_minute_agg |        2.01 |   ops/s |
|                                                 Max Throughput |                            date_histogram_minute_agg |        2.01 |   ops/s |
|                                        50th percentile latency |                            date_histogram_minute_agg |     40.6714 |      ms |
|                                        90th percentile latency |                            date_histogram_minute_agg |      41.426 |      ms |
|                                        99th percentile latency |                            date_histogram_minute_agg |     45.7043 |      ms |
|                                       100th percentile latency |                            date_histogram_minute_agg |     48.2114 |      ms |
|                                   50th percentile service time |                            date_histogram_minute_agg |     39.3579 |      ms |
|                                   90th percentile service time |                            date_histogram_minute_agg |     40.0998 |      ms |
|                                   99th percentile service time |                            date_histogram_minute_agg |     44.5748 |      ms |
|                                  100th percentile service time |                            date_histogram_minute_agg |     47.3376 |      ms |
|                                                     error rate |                            date_histogram_minute_agg |           0 |       % |
|                                                 Min Throughput |                                               scroll |       49.93 | pages/s |
|                                                Mean Throughput |                                               scroll |       49.95 | pages/s |
|                                              Median Throughput |                                               scroll |       49.95 | pages/s |
|                                                 Max Throughput |                                               scroll |       49.96 | pages/s |
|                                        50th percentile latency |                                               scroll |       474.4 |      ms |
|                                        90th percentile latency |                                               scroll |     492.603 |      ms |
|                                        99th percentile latency |                                               scroll |     527.337 |      ms |
|                                       100th percentile latency |                                               scroll |     527.458 |      ms |
|                                   50th percentile service time |                                               scroll |     473.573 |      ms |
|                                   90th percentile service time |                                               scroll |     488.858 |      ms |
|                                   99th percentile service time |                                               scroll |     515.141 |      ms |
|                                  100th percentile service time |                                               scroll |     523.024 |      ms |
|                                                     error rate |                                               scroll |           0 |       % |
|                                                 Min Throughput |                              query-string-on-message |        2.01 |   ops/s |
|                                                Mean Throughput |                              query-string-on-message |        2.01 |   ops/s |
|                                              Median Throughput |                              query-string-on-message |        2.01 |   ops/s |
|                                                 Max Throughput |                              query-string-on-message |        2.01 |   ops/s |
|                                        50th percentile latency |                              query-string-on-message |     6.56308 |      ms |
|                                        90th percentile latency |                              query-string-on-message |     6.85023 |      ms |
|                                        99th percentile latency |                              query-string-on-message |     7.27623 |      ms |
|                                       100th percentile latency |                              query-string-on-message |     7.46331 |      ms |
|                                   50th percentile service time |                              query-string-on-message |     5.12544 |      ms |
|                                   90th percentile service time |                              query-string-on-message |     5.27254 |      ms |
|                                   99th percentile service time |                              query-string-on-message |     5.91078 |      ms |
|                                  100th percentile service time |                              query-string-on-message |     6.30245 |      ms |
|                                                     error rate |                              query-string-on-message |           0 |       % |
|                                                 Min Throughput |                     query-string-on-message-filtered |        2.01 |   ops/s |
|                                                Mean Throughput |                     query-string-on-message-filtered |        2.01 |   ops/s |
|                                              Median Throughput |                     query-string-on-message-filtered |        2.01 |   ops/s |
|                                                 Max Throughput |                     query-string-on-message-filtered |        2.01 |   ops/s |
|                                        50th percentile latency |                     query-string-on-message-filtered |     13.6616 |      ms |
|                                        90th percentile latency |                     query-string-on-message-filtered |     14.1168 |      ms |
|                                        99th percentile latency |                     query-string-on-message-filtered |     16.5391 |      ms |
|                                       100th percentile latency |                     query-string-on-message-filtered |     18.5841 |      ms |
|                                   50th percentile service time |                     query-string-on-message-filtered |      12.356 |      ms |
|                                   90th percentile service time |                     query-string-on-message-filtered |     12.5476 |      ms |
|                                   99th percentile service time |                     query-string-on-message-filtered |     15.1944 |      ms |
|                                  100th percentile service time |                     query-string-on-message-filtered |     17.5608 |      ms |
|                                                     error rate |                     query-string-on-message-filtered |           0 |       % |
|                                                 Min Throughput |          query-string-on-message-filtered-sorted-num |        2.01 |   ops/s |
|                                                Mean Throughput |          query-string-on-message-filtered-sorted-num |        2.01 |   ops/s |
|                                              Median Throughput |          query-string-on-message-filtered-sorted-num |        2.01 |   ops/s |
|                                                 Max Throughput |          query-string-on-message-filtered-sorted-num |        2.01 |   ops/s |
|                                        50th percentile latency |          query-string-on-message-filtered-sorted-num |     29.7827 |      ms |
|                                        90th percentile latency |          query-string-on-message-filtered-sorted-num |     30.3132 |      ms |
|                                        99th percentile latency |          query-string-on-message-filtered-sorted-num |     35.2908 |      ms |
|                                       100th percentile latency |          query-string-on-message-filtered-sorted-num |     35.7501 |      ms |
|                                   50th percentile service time |          query-string-on-message-filtered-sorted-num |     28.5028 |      ms |
|                                   90th percentile service time |          query-string-on-message-filtered-sorted-num |     29.0703 |      ms |
|                                   99th percentile service time |          query-string-on-message-filtered-sorted-num |     34.0893 |      ms |
|                                  100th percentile service time |          query-string-on-message-filtered-sorted-num |     34.3734 |      ms |
|                                                     error rate |          query-string-on-message-filtered-sorted-num |           0 |       % |
|                                                 Min Throughput |                      sort_keyword_can_match_shortcut |        2.01 |   ops/s |
|                                                Mean Throughput |                      sort_keyword_can_match_shortcut |        2.01 |   ops/s |
|                                              Median Throughput |                      sort_keyword_can_match_shortcut |        2.01 |   ops/s |
|                                                 Max Throughput |                      sort_keyword_can_match_shortcut |        2.01 |   ops/s |
|                                        50th percentile latency |                      sort_keyword_can_match_shortcut |     5.44101 |      ms |
|                                        90th percentile latency |                      sort_keyword_can_match_shortcut |     5.90336 |      ms |
|                                        99th percentile latency |                      sort_keyword_can_match_shortcut |     6.06663 |      ms |
|                                       100th percentile latency |                      sort_keyword_can_match_shortcut |     6.07683 |      ms |
|                                   50th percentile service time |                      sort_keyword_can_match_shortcut |     4.25123 |      ms |
|                                   90th percentile service time |                      sort_keyword_can_match_shortcut |     4.33295 |      ms |
|                                   99th percentile service time |                      sort_keyword_can_match_shortcut |     4.85899 |      ms |
|                                  100th percentile service time |                      sort_keyword_can_match_shortcut |     5.02462 |      ms |
|                                                     error rate |                      sort_keyword_can_match_shortcut |           0 |       % |
|                                                 Min Throughput |                   sort_keyword_no_can_match_shortcut |        2.01 |   ops/s |
|                                                Mean Throughput |                   sort_keyword_no_can_match_shortcut |        2.01 |   ops/s |
|                                              Median Throughput |                   sort_keyword_no_can_match_shortcut |        2.01 |   ops/s |
|                                                 Max Throughput |                   sort_keyword_no_can_match_shortcut |        2.01 |   ops/s |
|                                        50th percentile latency |                   sort_keyword_no_can_match_shortcut |     5.66713 |      ms |
|                                        90th percentile latency |                   sort_keyword_no_can_match_shortcut |     6.05356 |      ms |
|                                        99th percentile latency |                   sort_keyword_no_can_match_shortcut |     6.15447 |      ms |
|                                       100th percentile latency |                   sort_keyword_no_can_match_shortcut |     6.19286 |      ms |
|                                   50th percentile service time |                   sort_keyword_no_can_match_shortcut |     4.32785 |      ms |
|                                   90th percentile service time |                   sort_keyword_no_can_match_shortcut |     4.40497 |      ms |
|                                   99th percentile service time |                   sort_keyword_no_can_match_shortcut |     4.73118 |      ms |
|                                  100th percentile service time |                   sort_keyword_no_can_match_shortcut |     4.97784 |      ms |
|                                                     error rate |                   sort_keyword_no_can_match_shortcut |           0 |       % |
|                                                 Min Throughput |                                    sort_numeric_desc |        2.01 |   ops/s |
|                                                Mean Throughput |                                    sort_numeric_desc |        2.01 |   ops/s |
|                                              Median Throughput |                                    sort_numeric_desc |        2.01 |   ops/s |
|                                                 Max Throughput |                                    sort_numeric_desc |        2.01 |   ops/s |
|                                        50th percentile latency |                                    sort_numeric_desc |     6.71916 |      ms |
|                                        90th percentile latency |                                    sort_numeric_desc |     7.07773 |      ms |
|                                        99th percentile latency |                                    sort_numeric_desc |     7.56936 |      ms |
|                                       100th percentile latency |                                    sort_numeric_desc |     7.82342 |      ms |
|                                   50th percentile service time |                                    sort_numeric_desc |     5.45731 |      ms |
|                                   90th percentile service time |                                    sort_numeric_desc |     5.53969 |      ms |
|                                   99th percentile service time |                                    sort_numeric_desc |      5.8956 |      ms |
|                                  100th percentile service time |                                    sort_numeric_desc |     6.09782 |      ms |
|                                                     error rate |                                    sort_numeric_desc |           0 |       % |
|                                                 Min Throughput |                                     sort_numeric_asc |        2.01 |   ops/s |
|                                                Mean Throughput |                                     sort_numeric_asc |        2.01 |   ops/s |
|                                              Median Throughput |                                     sort_numeric_asc |        2.01 |   ops/s |
|                                                 Max Throughput |                                     sort_numeric_asc |        2.01 |   ops/s |
|                                        50th percentile latency |                                     sort_numeric_asc |     5.73872 |      ms |
|                                        90th percentile latency |                                     sort_numeric_asc |     6.12636 |      ms |
|                                        99th percentile latency |                                     sort_numeric_asc |     6.87171 |      ms |
|                                       100th percentile latency |                                     sort_numeric_asc |     6.98314 |      ms |
|                                   50th percentile service time |                                     sort_numeric_asc |     4.44547 |      ms |
|                                   90th percentile service time |                                     sort_numeric_asc |     4.51035 |      ms |
|                                   99th percentile service time |                                     sort_numeric_asc |     4.56265 |      ms |
|                                  100th percentile service time |                                     sort_numeric_asc |     4.57383 |      ms |
|                                                     error rate |                                     sort_numeric_asc |           0 |       % |
|                                                 Min Throughput |                         sort_numeric_desc_with_match |        2.01 |   ops/s |
|                                                Mean Throughput |                         sort_numeric_desc_with_match |        2.01 |   ops/s |
|                                              Median Throughput |                         sort_numeric_desc_with_match |        2.01 |   ops/s |
|                                                 Max Throughput |                         sort_numeric_desc_with_match |        2.01 |   ops/s |
|                                        50th percentile latency |                         sort_numeric_desc_with_match |      4.0699 |      ms |
|                                        90th percentile latency |                         sort_numeric_desc_with_match |     4.44637 |      ms |
|                                        99th percentile latency |                         sort_numeric_desc_with_match |     4.66456 |      ms |
|                                       100th percentile latency |                         sort_numeric_desc_with_match |      4.6777 |      ms |
|                                   50th percentile service time |                         sort_numeric_desc_with_match |     2.81628 |      ms |
|                                   90th percentile service time |                         sort_numeric_desc_with_match |     2.87464 |      ms |
|                                   99th percentile service time |                         sort_numeric_desc_with_match |     2.96952 |      ms |
|                                  100th percentile service time |                         sort_numeric_desc_with_match |     2.99504 |      ms |
|                                                     error rate |                         sort_numeric_desc_with_match |           0 |       % |
|                                                 Min Throughput |                          sort_numeric_asc_with_match |        2.01 |   ops/s |
|                                                Mean Throughput |                          sort_numeric_asc_with_match |        2.01 |   ops/s |
|                                              Median Throughput |                          sort_numeric_asc_with_match |        2.01 |   ops/s |
|                                                 Max Throughput |                          sort_numeric_asc_with_match |        2.01 |   ops/s |
|                                        50th percentile latency |                          sort_numeric_asc_with_match |     4.03045 |      ms |
|                                        90th percentile latency |                          sort_numeric_asc_with_match |     4.44824 |      ms |
|                                        99th percentile latency |                          sort_numeric_asc_with_match |     6.07423 |      ms |
|                                       100th percentile latency |                          sort_numeric_asc_with_match |     7.44716 |      ms |
|                                   50th percentile service time |                          sort_numeric_asc_with_match |     2.73881 |      ms |
|                                   90th percentile service time |                          sort_numeric_asc_with_match |     2.80791 |      ms |
|                                   99th percentile service time |                          sort_numeric_asc_with_match |     4.39589 |      ms |
|                                  100th percentile service time |                          sort_numeric_asc_with_match |     5.81636 |      ms |
|                                                     error rate |                          sort_numeric_asc_with_match |           0 |       % |
|                                                 Min Throughput |     range_field_conjunction_big_range_big_term_query |        2.01 |   ops/s |
|                                                Mean Throughput |     range_field_conjunction_big_range_big_term_query |        2.01 |   ops/s |
|                                              Median Throughput |     range_field_conjunction_big_range_big_term_query |        2.01 |   ops/s |
|                                                 Max Throughput |     range_field_conjunction_big_range_big_term_query |        2.01 |   ops/s |
|                                        50th percentile latency |     range_field_conjunction_big_range_big_term_query |     4.07563 |      ms |
|                                        90th percentile latency |     range_field_conjunction_big_range_big_term_query |     4.46296 |      ms |
|                                        99th percentile latency |     range_field_conjunction_big_range_big_term_query |      4.5549 |      ms |
|                                       100th percentile latency |     range_field_conjunction_big_range_big_term_query |     4.59306 |      ms |
|                                   50th percentile service time |     range_field_conjunction_big_range_big_term_query |     2.72751 |      ms |
|                                   90th percentile service time |     range_field_conjunction_big_range_big_term_query |     2.81156 |      ms |
|                                   99th percentile service time |     range_field_conjunction_big_range_big_term_query |     2.86617 |      ms |
|                                  100th percentile service time |     range_field_conjunction_big_range_big_term_query |     2.87729 |      ms |
|                                                     error rate |     range_field_conjunction_big_range_big_term_query |           0 |       % |
|                                                 Min Throughput |   range_field_disjunction_big_range_small_term_query |        2.01 |   ops/s |
|                                                Mean Throughput |   range_field_disjunction_big_range_small_term_query |        2.01 |   ops/s |
|                                              Median Throughput |   range_field_disjunction_big_range_small_term_query |        2.01 |   ops/s |
|                                                 Max Throughput |   range_field_disjunction_big_range_small_term_query |        2.01 |   ops/s |
|                                        50th percentile latency |   range_field_disjunction_big_range_small_term_query |      3.6293 |      ms |
|                                        90th percentile latency |   range_field_disjunction_big_range_small_term_query |     4.10674 |      ms |
|                                        99th percentile latency |   range_field_disjunction_big_range_small_term_query |     4.24425 |      ms |
|                                       100th percentile latency |   range_field_disjunction_big_range_small_term_query |     4.24948 |      ms |
|                                   50th percentile service time |   range_field_disjunction_big_range_small_term_query |     2.41732 |      ms |
|                                   90th percentile service time |   range_field_disjunction_big_range_small_term_query |     2.47915 |      ms |
|                                   99th percentile service time |   range_field_disjunction_big_range_small_term_query |     2.58003 |      ms |
|                                  100th percentile service time |   range_field_disjunction_big_range_small_term_query |     2.60652 |      ms |
|                                                     error rate |   range_field_disjunction_big_range_small_term_query |           0 |       % |
|                                                 Min Throughput | range_field_conjunction_small_range_small_term_query |        2.01 |   ops/s |
|                                                Mean Throughput | range_field_conjunction_small_range_small_term_query |        2.01 |   ops/s |
|                                              Median Throughput | range_field_conjunction_small_range_small_term_query |        2.01 |   ops/s |
|                                                 Max Throughput | range_field_conjunction_small_range_small_term_query |        2.01 |   ops/s |
|                                        50th percentile latency | range_field_conjunction_small_range_small_term_query |     3.86326 |      ms |
|                                        90th percentile latency | range_field_conjunction_small_range_small_term_query |     4.31881 |      ms |
|                                        99th percentile latency | range_field_conjunction_small_range_small_term_query |     4.47051 |      ms |
|                                       100th percentile latency | range_field_conjunction_small_range_small_term_query |      4.5248 |      ms |
|                                   50th percentile service time | range_field_conjunction_small_range_small_term_query |     2.58415 |      ms |
|                                   90th percentile service time | range_field_conjunction_small_range_small_term_query |     2.65819 |      ms |
|                                   99th percentile service time | range_field_conjunction_small_range_small_term_query |     2.74241 |      ms |
|                                  100th percentile service time | range_field_conjunction_small_range_small_term_query |     2.78363 |      ms |
|                                                     error rate | range_field_conjunction_small_range_small_term_query |           0 |       % |
|                                                 Min Throughput |   range_field_conjunction_small_range_big_term_query |        2.01 |   ops/s |
|                                                Mean Throughput |   range_field_conjunction_small_range_big_term_query |        2.01 |   ops/s |
|                                              Median Throughput |   range_field_conjunction_small_range_big_term_query |        2.01 |   ops/s |
|                                                 Max Throughput |   range_field_conjunction_small_range_big_term_query |        2.01 |   ops/s |
|                                        50th percentile latency |   range_field_conjunction_small_range_big_term_query |     3.65862 |      ms |
|                                        90th percentile latency |   range_field_conjunction_small_range_big_term_query |     4.00879 |      ms |
|                                        99th percentile latency |   range_field_conjunction_small_range_big_term_query |     4.25084 |      ms |
|                                       100th percentile latency |   range_field_conjunction_small_range_big_term_query |     4.30381 |      ms |
|                                   50th percentile service time |   range_field_conjunction_small_range_big_term_query |     2.34114 |      ms |
|                                   90th percentile service time |   range_field_conjunction_small_range_big_term_query |      2.4178 |      ms |
|                                   99th percentile service time |   range_field_conjunction_small_range_big_term_query |      2.4834 |      ms |
|                                  100th percentile service time |   range_field_conjunction_small_range_big_term_query |     2.49839 |      ms |
|                                                     error rate |   range_field_conjunction_small_range_big_term_query |           0 |       % |
|                                                 Min Throughput |                                range-auto-date-histo |        0.11 |   ops/s |
|                                                Mean Throughput |                                range-auto-date-histo |        0.11 |   ops/s |
|                                              Median Throughput |                                range-auto-date-histo |        0.11 |   ops/s |
|                                                 Max Throughput |                                range-auto-date-histo |        0.11 |   ops/s |
|                                        50th percentile latency |                                range-auto-date-histo | 2.13925e+06 |      ms |
|                                        90th percentile latency |                                range-auto-date-histo | 2.47186e+06 |      ms |
|                                        99th percentile latency |                                range-auto-date-histo | 2.54675e+06 |      ms |
|                                       100th percentile latency |                                range-auto-date-histo |  2.5509e+06 |      ms |
|                                   50th percentile service time |                                range-auto-date-histo |        8904 |      ms |
|                                   90th percentile service time |                                range-auto-date-histo |     9109.89 |      ms |
|                                   99th percentile service time |                                range-auto-date-histo |     9263.96 |      ms |
|                                  100th percentile service time |                                range-auto-date-histo |     9265.77 |      ms |
|                                                     error rate |                                range-auto-date-histo |           0 |       % |
|                                                 Min Throughput |                   range-auto-date-histo-with-metrics |        0.05 |   ops/s |
|                                                Mean Throughput |                   range-auto-date-histo-with-metrics |        0.05 |   ops/s |
|                                              Median Throughput |                   range-auto-date-histo-with-metrics |        0.05 |   ops/s |
|                                                 Max Throughput |                   range-auto-date-histo-with-metrics |        0.05 |   ops/s |
|                                        50th percentile latency |                   range-auto-date-histo-with-metrics | 5.40729e+06 |      ms |
|                                        90th percentile latency |                   range-auto-date-histo-with-metrics |   6.284e+06 |      ms |
|                                        99th percentile latency |                   range-auto-date-histo-with-metrics | 6.48165e+06 |      ms |
|                                       100th percentile latency |                   range-auto-date-histo-with-metrics | 6.49266e+06 |      ms |
|                                   50th percentile service time |                   range-auto-date-histo-with-metrics |     22396.9 |      ms |
|                                   90th percentile service time |                   range-auto-date-histo-with-metrics |     22549.7 |      ms |
|                                   99th percentile service time |                   range-auto-date-histo-with-metrics |     22677.5 |      ms |
|                                  100th percentile service time |                   range-auto-date-histo-with-metrics |     22698.3 |      ms |
|                                                     error rate |                   range-auto-date-histo-with-metrics |           0 |       % |
|                                                 Min Throughput |                                          range-agg-1 |        2.01 |   ops/s |
|                                                Mean Throughput |                                          range-agg-1 |        2.01 |   ops/s |
|                                              Median Throughput |                                          range-agg-1 |        2.01 |   ops/s |
|                                                 Max Throughput |                                          range-agg-1 |        2.01 |   ops/s |
|                                        50th percentile latency |                                          range-agg-1 |     3.85546 |      ms |
|                                        90th percentile latency |                                          range-agg-1 |     4.25129 |      ms |
|                                        99th percentile latency |                                          range-agg-1 |     4.43828 |      ms |
|                                       100th percentile latency |                                          range-agg-1 |     4.45281 |      ms |
|                                   50th percentile service time |                                          range-agg-1 |     2.54375 |      ms |
|                                   90th percentile service time |                                          range-agg-1 |     2.63262 |      ms |
|                                   99th percentile service time |                                          range-agg-1 |     2.77577 |      ms |
|                                  100th percentile service time |                                          range-agg-1 |     2.86534 |      ms |
|                                                     error rate |                                          range-agg-1 |           0 |       % |
|                                                 Min Throughput |                                          range-agg-2 |        2.01 |   ops/s |
|                                                Mean Throughput |                                          range-agg-2 |        2.01 |   ops/s |
|                                              Median Throughput |                                          range-agg-2 |        2.01 |   ops/s |
|                                                 Max Throughput |                                          range-agg-2 |        2.01 |   ops/s |
|                                        50th percentile latency |                                          range-agg-2 |     4.14894 |      ms |
|                                        90th percentile latency |                                          range-agg-2 |     4.62475 |      ms |
|                                        99th percentile latency |                                          range-agg-2 |     4.79056 |      ms |
|                                       100th percentile latency |                                          range-agg-2 |     4.79911 |      ms |
|                                   50th percentile service time |                                          range-agg-2 |     2.92558 |      ms |
|                                   90th percentile service time |                                          range-agg-2 |     3.04502 |      ms |
|                                   99th percentile service time |                                          range-agg-2 |     3.18081 |      ms |
|                                  100th percentile service time |                                          range-agg-2 |     3.22458 |      ms |
|                                                     error rate |                                          range-agg-2 |           0 |       % |
|                                                 Min Throughput |                                  cardinality-agg-low |        2.01 |   ops/s |
|                                                Mean Throughput |                                  cardinality-agg-low |        2.01 |   ops/s |
|                                              Median Throughput |                                  cardinality-agg-low |        2.01 |   ops/s |
|                                                 Max Throughput |                                  cardinality-agg-low |        2.01 |   ops/s |
|                                        50th percentile latency |                                  cardinality-agg-low |     5.35886 |      ms |
|                                        90th percentile latency |                                  cardinality-agg-low |     5.81251 |      ms |
|                                        99th percentile latency |                                  cardinality-agg-low |     5.92569 |      ms |
|                                       100th percentile latency |                                  cardinality-agg-low |     5.93762 |      ms |
|                                   50th percentile service time |                                  cardinality-agg-low |     4.12306 |      ms |
|                                   90th percentile service time |                                  cardinality-agg-low |     4.19725 |      ms |
|                                   99th percentile service time |                                  cardinality-agg-low |     4.28697 |      ms |
|                                  100th percentile service time |                                  cardinality-agg-low |     4.29233 |      ms |
|                                                     error rate |                                  cardinality-agg-low |           0 |       % |
|                                                 Min Throughput |                                 cardinality-agg-high |         0.4 |   ops/s |
|                                                Mean Throughput |                                 cardinality-agg-high |         0.4 |   ops/s |
|                                              Median Throughput |                                 cardinality-agg-high |         0.4 |   ops/s |
|                                                 Max Throughput |                                 cardinality-agg-high |         0.4 |   ops/s |
|                                        50th percentile latency |                                 cardinality-agg-high |      507512 |      ms |
|                                        90th percentile latency |                                 cardinality-agg-high |      588556 |      ms |
|                                        99th percentile latency |                                 cardinality-agg-high |      606557 |      ms |
|                                       100th percentile latency |                                 cardinality-agg-high |      607600 |      ms |
|                                   50th percentile service time |                                 cardinality-agg-high |     2516.06 |      ms |
|                                   90th percentile service time |                                 cardinality-agg-high |     2585.76 |      ms |
|                                   99th percentile service time |                                 cardinality-agg-high |     2628.52 |      ms |
|                                  100th percentile service time |                                 cardinality-agg-high |     2632.61 |      ms |
|                                                     error rate |                                 cardinality-agg-high |           0 |       % |
</details>

author_association: COLLABORATOR
user: login: opensearch-ci-bot
created_at: 2025-04-03T08:22:37Z
body: <details><summary>Benchmark Baseline Comparison Results</summary>

#### Benchmark Results for Job: https://build.ci.opensearch.org/job/benchmark-compare/52/
|                                                        Metric |                                                 Task |    Baseline |   Contender |     Diff |    Unit |
|--------------------------------------------------------------:|-----------------------------------------------------:|------------:|------------:|---------:|--------:|
|                    Cumulative indexing time of primary shards |                                                      |           0 |           0 |        0 |     min |
|             Min cumulative indexing time across primary shard |                                                      |           0 |           0 |        0 |     min |
|          Median cumulative indexing time across primary shard |                                                      |           0 |           0 |        0 |     min |
|             Max cumulative indexing time across primary shard |                                                      |           0 |           0 |        0 |     min |
|           Cumulative indexing throttle time of primary shards |                                                      |           0 |           0 |        0 |     min |
|    Min cumulative indexing throttle time across primary shard |                                                      |           0 |           0 |        0 |     min |
| Median cumulative indexing throttle time across primary shard |                                                      |           0 |           0 |        0 |     min |
|    Max cumulative indexing throttle time across primary shard |                                                      |           0 |           0 |        0 |     min |
|                       Cumulative merge time of primary shards |                                                      |           0 |           0 |        0 |     min |
|                      Cumulative merge count of primary shards |                                                      |           0 |           0 |        0 |         |
|                Min cumulative merge time across primary shard |                                                      |           0 |           0 |        0 |     min |
|             Median cumulative merge time across primary shard |                                                      |           0 |           0 |        0 |     min |
|                Max cumulative merge time across primary shard |                                                      |           0 |           0 |        0 |     min |
|              Cumulative merge throttle time of primary shards |                                                      |           0 |           0 |        0 |     min |
|       Min cumulative merge throttle time across primary shard |                                                      |           0 |           0 |        0 |     min |
|    Median cumulative merge throttle time across primary shard |                                                      |           0 |           0 |        0 |     min |
|       Max cumulative merge throttle time across primary shard |                                                      |           0 |           0 |        0 |     min |
|                     Cumulative refresh time of primary shards |                                                      |           0 |           0 |        0 |     min |
|                    Cumulative refresh count of primary shards |                                                      |           4 |           4 |        0 |         |
|              Min cumulative refresh time across primary shard |                                                      |           0 |           0 |        0 |     min |
|           Median cumulative refresh time across primary shard |                                                      |           0 |           0 |        0 |     min |
|              Max cumulative refresh time across primary shard |                                                      |           0 |           0 |        0 |     min |
|                       Cumulative flush time of primary shards |                                                      |           0 |           0 |        0 |     min |
|                      Cumulative flush count of primary shards |                                                      |           1 |           1 |        0 |         |
|                Min cumulative flush time across primary shard |                                                      |           0 |           0 |        0 |     min |
|             Median cumulative flush time across primary shard |                                                      |           0 |           0 |        0 |     min |
|                Max cumulative flush time across primary shard |                                                      |           0 |           0 |        0 |     min |
|                                       Total Young Gen GC time |                                                      |       1.812 |       1.613 |   -0.199 |       s |
|                                      Total Young Gen GC count |                                                      |          52 |          53 |        1 |         |
|                                         Total Old Gen GC time |                                                      |           0 |           0 |        0 |       s |
|                                        Total Old Gen GC count |                                                      |           0 |           0 |        0 |         |
|                                                    Store size |                                                      |     22.1906 |     22.1906 |        0 |      GB |
|                                                 Translog size |                                                      | 5.12227e-08 | 5.12227e-08 |        0 |      GB |
|                                        Heap used for segments |                                                      |           0 |           0 |        0 |      MB |
|                                      Heap used for doc values |                                                      |           0 |           0 |        0 |      MB |
|                                           Heap used for terms |                                                      |           0 |           0 |        0 |      MB |
|                                           Heap used for norms |                                                      |           0 |           0 |        0 |      MB |
|                                          Heap used for points |                                                      |           0 |           0 |        0 |      MB |
|                                   Heap used for stored fields |                                                      |           0 |           0 |        0 |      MB |
|                                                 Segment count |                                                      |          10 |          10 |        0 |         |
|                                                Min Throughput |                           wait-for-snapshot-recovery | 4.17378e+07 | 4.18059e+07 |    68104 |  byte/s |
|                                               Mean Throughput |                           wait-for-snapshot-recovery | 4.17378e+07 | 4.18059e+07 |    68104 |  byte/s |
|                                             Median Throughput |                           wait-for-snapshot-recovery | 4.17378e+07 | 4.18059e+07 |    68104 |  byte/s |
|                                                Max Throughput |                           wait-for-snapshot-recovery | 4.17378e+07 | 4.18059e+07 |    68104 |  byte/s |
|                                      100th percentile latency |                           wait-for-snapshot-recovery |      565378 |      564521 |  -857.25 |      ms |
|                                 100th percentile service time |                           wait-for-snapshot-recovery |      565378 |      564521 |  -857.25 |      ms |
|                                                    error rate |                           wait-for-snapshot-recovery |           0 |           0 |        0 |       % |
|                                                Min Throughput |                             wait-until-merges-finish |     102.711 |      105.11 |  2.39892 |   ops/s |
|                                               Mean Throughput |                             wait-until-merges-finish |     102.711 |      105.11 |  2.39892 |   ops/s |
|                                             Median Throughput |                             wait-until-merges-finish |     102.711 |      105.11 |  2.39892 |   ops/s |
|                                                Max Throughput |                             wait-until-merges-finish |     102.711 |      105.11 |  2.39892 |   ops/s |
|                                      100th percentile latency |                             wait-until-merges-finish |     9.44703 |      9.2149 | -0.23213 |      ms |
|                                 100th percentile service time |                             wait-until-merges-finish |     9.44703 |      9.2149 | -0.23213 |      ms |
|                                                    error rate |                             wait-until-merges-finish |           0 |           0 |        0 |       % |
|                                                Min Throughput |                                              default |     2.00517 |     2.00528 |  0.00011 |   ops/s |
|                                               Mean Throughput |                                              default |     2.00628 |     2.00641 |  0.00013 |   ops/s |
|                                             Median Throughput |                                              default |     2.00619 |     2.00632 |  0.00013 |   ops/s |
|                                                Max Throughput |                                              default |     2.00772 |     2.00787 |  0.00016 |   ops/s |
|                                       50th percentile latency |                                              default |      7.4769 |     6.83109 | -0.64582 |      ms |
|                                       90th percentile latency |                                              default |     8.12296 |     7.28712 | -0.83584 |      ms |
|                                       99th percentile latency |                                              default |     9.25345 |     8.02337 | -1.23008 |      ms |
|                                      100th percentile latency |                                              default |     9.78998 |     8.03111 | -1.75887 |      ms |
|                                  50th percentile service time |                                              default |     6.17464 |     5.52838 | -0.64626 |      ms |
|                                  90th percentile service time |                                              default |      6.6723 |     5.98272 | -0.68958 |      ms |
|                                  99th percentile service time |                                              default |     7.74496 |     6.51492 | -1.23004 |      ms |
|                                 100th percentile service time |                                              default |      8.3178 |     6.55637 | -1.76144 |      ms |
|                                                    error rate |                                              default |           0 |           0 |        0 |       % |
|                                                Min Throughput |                                  desc_sort_timestamp |     2.00581 |     2.00589 |    8e-05 |   ops/s |
|                                               Mean Throughput |                                  desc_sort_timestamp |     2.00704 |     2.00715 |   0.0001 |   ops/s |
|                                             Median Throughput |                                  desc_sort_timestamp |     2.00695 |     2.00705 |   0.0001 |   ops/s |
|                                                Max Throughput |                                  desc_sort_timestamp |     2.00865 |     2.00879 |  0.00013 |   ops/s |
|                                       50th percentile latency |                                  desc_sort_timestamp |      8.0572 |     7.57753 | -0.47967 |      ms |
|                                       90th percentile latency |                                  desc_sort_timestamp |     8.71107 |     8.12121 | -0.58985 |      ms |
|                                       99th percentile latency |                                  desc_sort_timestamp |     10.4992 |     9.67222 | -0.82695 |      ms |
|                                      100th percentile latency |                                  desc_sort_timestamp |     11.1332 |     10.1711 | -0.96217 |      ms |
|                                  50th percentile service time |                                  desc_sort_timestamp |     6.71952 |      6.1954 | -0.52412 |      ms |
|                                  90th percentile service time |                                  desc_sort_timestamp |     7.30529 |     6.79498 | -0.51031 |      ms |
|                                  99th percentile service time |                                  desc_sort_timestamp |     9.04405 |     8.07599 | -0.96806 |      ms |
|                                 100th percentile service time |                                  desc_sort_timestamp |     9.59729 |     8.51967 | -1.07761 |      ms |
|                                                    error rate |                                  desc_sort_timestamp |           0 |           0 |        0 |       % |
|                                                Min Throughput |                                   asc_sort_timestamp |     2.00641 |     2.00641 |       -0 |   ops/s |
|                                               Mean Throughput |                                   asc_sort_timestamp |     2.00777 |     2.00777 |       -0 |   ops/s |
|                                             Median Throughput |                                   asc_sort_timestamp |     2.00766 |     2.00766 |       -0 |   ops/s |
|                                                Max Throughput |                                   asc_sort_timestamp |     2.00954 |     2.00955 |    1e-05 |   ops/s |
|                                       50th percentile latency |                                   asc_sort_timestamp |     9.89219 |     9.35412 | -0.53807 |      ms |
|                                       90th percentile latency |                                   asc_sort_timestamp |     10.4871 |     9.78918 |  -0.6979 |      ms |
|                                       99th percentile latency |                                   asc_sort_timestamp |     12.9442 |     11.7457 | -1.19847 |      ms |
|                                      100th percentile latency |                                   asc_sort_timestamp |     13.6913 |     12.2157 | -1.47565 |      ms |
|                                  50th percentile service time |                                   asc_sort_timestamp |     8.48712 |     7.98773 | -0.49939 |      ms |
|                                  90th percentile service time |                                   asc_sort_timestamp |     8.84115 |     8.23209 | -0.60906 |      ms |
|                                  99th percentile service time |                                   asc_sort_timestamp |     11.9814 |     10.7044 | -1.27697 |      ms |
|                                 100th percentile service time |                                   asc_sort_timestamp |     12.8012 |     11.0681 | -1.73314 |      ms |
|                                                    error rate |                                   asc_sort_timestamp |           0 |           0 |        0 |       % |
|                                                Min Throughput |                       desc_sort_with_after_timestamp |     2.00253 |     2.00203 | -0.00051 |   ops/s |
|                                               Mean Throughput |                       desc_sort_with_after_timestamp |     2.00307 |     2.00246 | -0.00061 |   ops/s |
|                                             Median Throughput |                       desc_sort_with_after_timestamp |     2.00303 |     2.00242 | -0.00061 |   ops/s |
|                                                Max Throughput |                       desc_sort_with_after_timestamp |     2.00377 |     2.00302 | -0.00074 |   ops/s |
|                                       50th percentile latency |                       desc_sort_with_after_timestamp |      117.91 |     113.459 | -4.45033 |      ms |
|                                       90th percentile latency |                       desc_sort_with_after_timestamp |      122.98 |     115.679 | -7.30076 |      ms |
|                                       99th percentile latency |                       desc_sort_with_after_timestamp |     140.244 |     127.268 | -12.9765 |      ms |
|                                      100th percentile latency |                       desc_sort_with_after_timestamp |     143.557 |     128.152 | -15.4057 |      ms |
|                                  50th percentile service time |                       desc_sort_with_after_timestamp |       116.7 |     112.321 | -4.37934 |      ms |
|                                  90th percentile service time |                       desc_sort_with_after_timestamp |     121.959 |     114.465 | -7.49429 |      ms |
|                                  99th percentile service time |                       desc_sort_with_after_timestamp |     138.774 |     126.004 | -12.7699 |      ms |
|                                 100th percentile service time |                       desc_sort_with_after_timestamp |     142.225 |     127.054 | -15.1701 |      ms |
|                                                    error rate |                       desc_sort_with_after_timestamp |           0 |           0 |        0 |       % |
|                                                Min Throughput |                        asc_sort_with_after_timestamp |     2.00306 |     2.00364 |  0.00058 |   ops/s |
|                                               Mean Throughput |                        asc_sort_with_after_timestamp |     2.00371 |     2.00442 |  0.00071 |   ops/s |
|                                             Median Throughput |                        asc_sort_with_after_timestamp |     2.00366 |     2.00436 |   0.0007 |   ops/s |
|                                                Max Throughput |                        asc_sort_with_after_timestamp |     2.00455 |     2.00544 |  0.00089 |   ops/s |
|                                       50th percentile latency |                        asc_sort_with_after_timestamp |     224.161 |     216.204 |  -7.9573 |      ms |
|                                       90th percentile latency |                        asc_sort_with_after_timestamp |     237.436 |     219.289 | -18.1468 |      ms |
|                                       99th percentile latency |                        asc_sort_with_after_timestamp |     259.579 |     246.476 | -13.1032 |      ms |
|                                      100th percentile latency |                        asc_sort_with_after_timestamp |      260.46 |     250.726 | -9.73372 |      ms |
|                                  50th percentile service time |                        asc_sort_with_after_timestamp |     223.054 |     214.402 | -8.65193 |      ms |
|                                  90th percentile service time |                        asc_sort_with_after_timestamp |     236.244 |     217.462 | -18.7824 |      ms |
|                                  99th percentile service time |                        asc_sort_with_after_timestamp |     258.334 |     244.276 | -14.0584 |      ms |
|                                 100th percentile service time |                        asc_sort_with_after_timestamp |     258.899 |     248.306 | -10.5929 |      ms |
|                                                    error rate |                        asc_sort_with_after_timestamp |           0 |           0 |        0 |       % |
|                                                Min Throughput |               desc_sort_timestamp_can_match_shortcut |     2.00535 |     2.00561 |  0.00026 |   ops/s |
|                                               Mean Throughput |               desc_sort_timestamp_can_match_shortcut |     2.00648 |      2.0068 |  0.00032 |   ops/s |
|                                             Median Throughput |               desc_sort_timestamp_can_match_shortcut |      2.0064 |     2.00671 |  0.00031 |   ops/s |
|                                                Max Throughput |               desc_sort_timestamp_can_match_shortcut |     2.00795 |     2.00835 |   0.0004 |   ops/s |
|                                       50th percentile latency |               desc_sort_timestamp_can_match_shortcut |     8.11012 |     7.42587 | -0.68426 |      ms |
|                                       90th percentile latency |               desc_sort_timestamp_can_match_shortcut |      8.7833 |     7.80999 | -0.97331 |      ms |
|                                       99th percentile latency |               desc_sort_timestamp_can_match_shortcut |     11.0813 |      9.1266 | -1.95474 |      ms |
|                                      100th percentile latency |               desc_sort_timestamp_can_match_shortcut |     11.4418 |      9.5246 | -1.91722 |      ms |
|                                  50th percentile service time |               desc_sort_timestamp_can_match_shortcut |     6.78087 |     6.04727 |  -0.7336 |      ms |
|                                  90th percentile service time |               desc_sort_timestamp_can_match_shortcut |     7.40516 |     6.23341 | -1.17175 |      ms |
|                                  99th percentile service time |               desc_sort_timestamp_can_match_shortcut |     9.44493 |     7.63512 | -1.80981 |      ms |
|                                 100th percentile service time |               desc_sort_timestamp_can_match_shortcut |     9.76011 |     7.93663 | -1.82348 |      ms |
|                                                    error rate |               desc_sort_timestamp_can_match_shortcut |           0 |           0 |        0 |       % |
|                                                Min Throughput |            desc_sort_timestamp_no_can_match_shortcut |     2.00653 |     2.00655 |    2e-05 |   ops/s |
|                                               Mean Throughput |            desc_sort_timestamp_no_can_match_shortcut |     2.00792 |     2.00795 |    3e-05 |   ops/s |
|                                             Median Throughput |            desc_sort_timestamp_no_can_match_shortcut |     2.00781 |     2.00784 |    2e-05 |   ops/s |
|                                                Max Throughput |            desc_sort_timestamp_no_can_match_shortcut |     2.00972 |     2.00977 |    4e-05 |   ops/s |
|                                       50th percentile latency |            desc_sort_timestamp_no_can_match_shortcut |     7.30019 |      6.7835 |  -0.5167 |      ms |
|                                       90th percentile latency |            desc_sort_timestamp_no_can_match_shortcut |     7.73963 |     7.22356 | -0.51607 |      ms |
|                                       99th percentile latency |            desc_sort_timestamp_no_can_match_shortcut |     11.7309 |      8.1375 | -3.59339 |      ms |
|                                      100th percentile latency |            desc_sort_timestamp_no_can_match_shortcut |     11.7351 |     8.15911 | -3.57602 |      ms |
|                                  50th percentile service time |            desc_sort_timestamp_no_can_match_shortcut |     5.90063 |     5.43074 | -0.46989 |      ms |
|                                  90th percentile service time |            desc_sort_timestamp_no_can_match_shortcut |     6.14974 |     5.57684 |  -0.5729 |      ms |
|                                  99th percentile service time |            desc_sort_timestamp_no_can_match_shortcut |     10.4606 |     6.49646 | -3.96418 |      ms |
|                                 100th percentile service time |            desc_sort_timestamp_no_can_match_shortcut |     10.5591 |     6.63679 | -3.92232 |      ms |
|                                                    error rate |            desc_sort_timestamp_no_can_match_shortcut |           0 |           0 |        0 |       % |
|                                                Min Throughput |                asc_sort_timestamp_can_match_shortcut |      2.0065 |     2.00651 |    1e-05 |   ops/s |
|                                               Mean Throughput |                asc_sort_timestamp_can_match_shortcut |     2.00789 |      2.0079 |    1e-05 |   ops/s |
|                                             Median Throughput |                asc_sort_timestamp_can_match_shortcut |     2.00778 |     2.00779 |    1e-05 |   ops/s |
|                                                Max Throughput |                asc_sort_timestamp_can_match_shortcut |     2.00969 |     2.00971 |    1e-05 |   ops/s |
|                                       50th percentile latency |                asc_sort_timestamp_can_match_shortcut |      9.5988 |     8.67356 | -0.92524 |      ms |
|                                       90th percentile latency |                asc_sort_timestamp_can_match_shortcut |     9.98999 |      9.1211 |  -0.8689 |      ms |
|                                       99th percentile latency |                asc_sort_timestamp_can_match_shortcut |     11.7119 |     10.1767 | -1.53517 |      ms |
|                                      100th percentile latency |                asc_sort_timestamp_can_match_shortcut |     12.4527 |     11.0151 |  -1.4376 |      ms |
|                                  50th percentile service time |                asc_sort_timestamp_can_match_shortcut |     8.23057 |     7.39599 | -0.83458 |      ms |
|                                  90th percentile service time |                asc_sort_timestamp_can_match_shortcut |      8.4241 |     7.49423 | -0.92988 |      ms |
|                                  99th percentile service time |                asc_sort_timestamp_can_match_shortcut |     10.1176 |     8.74856 | -1.36899 |      ms |
|                                 100th percentile service time |                asc_sort_timestamp_can_match_shortcut |     10.8308 |     9.73906 | -1.09177 |      ms |
|                                                    error rate |                asc_sort_timestamp_can_match_shortcut |           0 |           0 |        0 |       % |
|                                                Min Throughput |             asc_sort_timestamp_no_can_match_shortcut |     2.00651 |     2.00652 |    1e-05 |   ops/s |
|                                               Mean Throughput |             asc_sort_timestamp_no_can_match_shortcut |     2.00789 |     2.00792 |    2e-05 |   ops/s |
|                                             Median Throughput |             asc_sort_timestamp_no_can_match_shortcut |     2.00779 |     2.00781 |    2e-05 |   ops/s |
|                                                Max Throughput |             asc_sort_timestamp_no_can_match_shortcut |      2.0097 |     2.00973 |    3e-05 |   ops/s |
|                                       50th percentile latency |             asc_sort_timestamp_no_can_match_shortcut |     9.57179 |     8.76229 |  -0.8095 |      ms |
|                                       90th percentile latency |             asc_sort_timestamp_no_can_match_shortcut |     9.91456 |     9.18949 | -0.72507 |      ms |
|                                       99th percentile latency |             asc_sort_timestamp_no_can_match_shortcut |      13.159 |     10.2762 | -2.88285 |      ms |
|                                      100th percentile latency |             asc_sort_timestamp_no_can_match_shortcut |     14.2304 |     11.1207 | -3.10967 |      ms |
|                                  50th percentile service time |             asc_sort_timestamp_no_can_match_shortcut |     8.09479 |     7.39028 | -0.70451 |      ms |
|                                  90th percentile service time |             asc_sort_timestamp_no_can_match_shortcut |      8.3612 |      7.5843 |  -0.7769 |      ms |
|                                  99th percentile service time |             asc_sort_timestamp_no_can_match_shortcut |     11.5637 |     9.07068 | -2.49303 |      ms |
|                                 100th percentile service time |             asc_sort_timestamp_no_can_match_shortcut |     12.4075 |     9.77161 | -2.63588 |      ms |
|                                                    error rate |             asc_sort_timestamp_no_can_match_shortcut |           0 |           0 |        0 |       % |
|                                                Min Throughput |                                                 term |     2.00633 |     2.00631 |   -2e-05 |   ops/s |
|                                               Mean Throughput |                                                 term |     2.00767 |     2.00766 |   -2e-05 |   ops/s |
|                                             Median Throughput |                                                 term |     2.00757 |     2.00755 |   -1e-05 |   ops/s |
|                                                Max Throughput |                                                 term |     2.00944 |     2.00941 |   -3e-05 |   ops/s |
|                                       50th percentile latency |                                                 term |     6.42623 |      6.3658 | -0.06043 |      ms |
|                                       90th percentile latency |                                                 term |     6.95846 |     6.76335 | -0.19511 |      ms |
|                                       99th percentile latency |                                                 term |     8.52532 |     7.84978 | -0.67553 |      ms |
|                                      100th percentile latency |                                                 term |      9.3412 |     8.24088 | -1.10032 |      ms |
|                                  50th percentile service time |                                                 term |     5.08711 |     4.93637 | -0.15073 |      ms |
|                                  90th percentile service time |                                                 term |     5.32488 |     5.12414 | -0.20075 |      ms |
|                                  99th percentile service time |                                                 term |     7.06841 |     6.00565 | -1.06276 |      ms |
|                                 100th percentile service time |                                                 term |     7.62532 |     6.02292 |  -1.6024 |      ms |
|                                                    error rate |                                                 term |           0 |           0 |        0 |       % |
|                                                Min Throughput |                                  multi_terms-keyword |     1.30629 |     1.11583 | -0.19046 |   ops/s |
|                                               Mean Throughput |                                  multi_terms-keyword |     1.30943 |     1.11735 | -0.19208 |   ops/s |
|                                             Median Throughput |                                  multi_terms-keyword |      1.3097 |      1.1174 | -0.19229 |   ops/s |
|                                                Max Throughput |                                  multi_terms-keyword |     1.31192 |     1.11863 | -0.19329 |   ops/s |
|                                       50th percentile latency |                                  multi_terms-keyword |       65827 |     98999.8 |  33172.8 |      ms |
|                                       90th percentile latency |                                  multi_terms-keyword |     76057.2 |      114570 |  38513.2 |      ms |
|                                       99th percentile latency |                                  multi_terms-keyword |     78352.3 |      118058 |  39706.1 |      ms |
|                                      100th percentile latency |                                  multi_terms-keyword |     78479.6 |      118254 |  39774.1 |      ms |
|                                  50th percentile service time |                                  multi_terms-keyword |     754.583 |     888.132 |   133.55 |      ms |
|                                  90th percentile service time |                                  multi_terms-keyword |     758.192 |     892.766 |  134.575 |      ms |
|                                  99th percentile service time |                                  multi_terms-keyword |     764.105 |     905.574 |  141.469 |      ms |
|                                 100th percentile service time |                                  multi_terms-keyword |     766.368 |     905.593 |  139.225 |      ms |
|                                                    error rate |                                  multi_terms-keyword |           0 |           0 |        0 |       % |
|                                                Min Throughput |                                        keyword-terms |     2.00451 |     2.00468 |  0.00016 |   ops/s |
|                                               Mean Throughput |                                        keyword-terms |     2.00548 |     2.00567 |  0.00019 |   ops/s |
|                                             Median Throughput |                                        keyword-terms |     2.00539 |      2.0056 |  0.00021 |   ops/s |
|                                                Max Throughput |                                        keyword-terms |     2.00672 |     2.00697 |  0.00025 |   ops/s |
|                                       50th percentile latency |                                        keyword-terms |     29.0048 |     42.4174 |  13.4126 |      ms |
|                                       90th percentile latency |                                        keyword-terms |     30.3357 |     42.9069 |  12.5712 |      ms |
|                                       99th percentile latency |                                        keyword-terms |     35.3771 |     43.4413 |  8.06426 |      ms |
|                                      100th percentile latency |                                        keyword-terms |     35.5951 |     43.5151 |  7.92002 |      ms |
|                                  50th percentile service time |                                        keyword-terms |     27.5094 |     41.0794 |  13.5701 |      ms |
|                                  90th percentile service time |                                        keyword-terms |     28.0402 |     41.3704 |  13.3301 |      ms |
|                                  99th percentile service time |                                        keyword-terms |     33.6306 |     42.1752 |  8.54455 |      ms |
|                                 100th percentile service time |                                        keyword-terms |      33.702 |     42.2269 |  8.52493 |      ms |
|                                                    error rate |                                        keyword-terms |           0 |           0 |        0 |       % |
|                                                Min Throughput |                        keyword-terms-low-cardinality |     2.00628 |     2.00614 | -0.00014 |   ops/s |
|                                               Mean Throughput |                        keyword-terms-low-cardinality |     2.00762 |     2.00744 | -0.00018 |   ops/s |
|                                             Median Throughput |                        keyword-terms-low-cardinality |     2.00752 |     2.00734 | -0.00018 |   ops/s |
|                                                Max Throughput |                        keyword-terms-low-cardinality |     2.00936 |     2.00915 | -0.00021 |   ops/s |
|                                       50th percentile latency |                        keyword-terms-low-cardinality |     25.8558 |     36.7567 |  10.9009 |      ms |
|                                       90th percentile latency |                        keyword-terms-low-cardinality |     26.3193 |      37.261 |  10.9418 |      ms |
|                                       99th percentile latency |                        keyword-terms-low-cardinality |     28.1901 |     39.1844 |  10.9943 |      ms |
|                                      100th percentile latency |                        keyword-terms-low-cardinality |     28.4085 |     39.5664 |   11.158 |      ms |
|                                  50th percentile service time |                        keyword-terms-low-cardinality |     23.5867 |     35.5911 |  12.0044 |      ms |
|                                  90th percentile service time |                        keyword-terms-low-cardinality |     23.8736 |     35.8307 |  11.9571 |      ms |
|                                  99th percentile service time |                        keyword-terms-low-cardinality |      26.893 |     37.5805 |  10.6876 |      ms |
|                                 100th percentile service time |                        keyword-terms-low-cardinality |     27.2872 |      38.089 |  10.8017 |      ms |
|                                                    error rate |                        keyword-terms-low-cardinality |           0 |           0 |        0 |       % |
|                                                Min Throughput |                                      composite-terms |     2.00225 |      2.0022 |   -5e-05 |   ops/s |
|                                               Mean Throughput |                                      composite-terms |     2.00273 |     2.00267 |   -5e-05 |   ops/s |
|                                             Median Throughput |                                      composite-terms |      2.0027 |     2.00264 |   -6e-05 |   ops/s |
|                                                Max Throughput |                                      composite-terms |     2.00336 |     2.00328 |   -7e-05 |   ops/s |
|                                       50th percentile latency |                                      composite-terms |     234.373 |      235.31 |  0.93695 |      ms |
|                                       90th percentile latency |                                      composite-terms |     272.777 |     238.882 | -33.8946 |      ms |
|                                       99th percentile latency |                                      composite-terms |     279.749 |     247.514 | -32.2354 |      ms |
|                                      100th percentile latency |                                      composite-terms |     280.834 |     253.864 | -26.9695 |      ms |
|                                  50th percentile service time |                                      composite-terms |     232.671 |     234.216 |  1.54498 |      ms |
|                                  90th percentile service time |                                      composite-terms |     271.669 |     237.571 | -34.0987 |      ms |
|                                  99th percentile service time |                                      composite-terms |     278.714 |      246.27 | -32.4436 |      ms |
|                                 100th percentile service time |                                      composite-terms |      279.33 |     252.555 | -26.7752 |      ms |
|                                                    error rate |                                      composite-terms |           0 |           0 |        0 |       % |
|                                                Min Throughput |                              composite_terms-keyword |      2.0003 |     2.00122 |  0.00092 |   ops/s |
|                                               Mean Throughput |                              composite_terms-keyword |     2.00036 |     2.00148 |  0.00112 |   ops/s |
|                                             Median Throughput |                              composite_terms-keyword |     2.00035 |     2.00147 |  0.00112 |   ops/s |
|                                                Max Throughput |                              composite_terms-keyword |     2.00045 |     2.00182 |  0.00137 |   ops/s |
|                                       50th percentile latency |                              composite_terms-keyword |     441.563 |     375.104 | -66.4592 |      ms |
|                                       90th percentile latency |                              composite_terms-keyword |     444.979 |     380.232 | -64.7473 |      ms |
|                                       99th percentile latency |                              composite_terms-keyword |     449.941 |     388.553 | -61.3879 |      ms |
|                                      100th percentile latency |                              composite_terms-keyword |     451.857 |     390.019 | -61.8379 |      ms |
|                                  50th percentile service time |                              composite_terms-keyword |      440.45 |     374.088 | -66.3618 |      ms |
|                                  90th percentile service time |                              composite_terms-keyword |     444.162 |     379.365 | -64.7966 |      ms |
|                                  99th percentile service time |                              composite_terms-keyword |     448.233 |     387.473 | -60.7599 |      ms |
|                                 100th percentile service time |                              composite_terms-keyword |     449.696 |     388.882 | -60.8147 |      ms |
|                                                    error rate |                              composite_terms-keyword |           0 |           0 |        0 |       % |
|                                                Min Throughput |                       composite-date_histogram-daily |     2.00617 |     2.00626 |    9e-05 |   ops/s |
|                                               Mean Throughput |                       composite-date_histogram-daily |     2.00747 |     2.00759 |  0.00012 |   ops/s |
|                                             Median Throughput |                       composite-date_histogram-daily |     2.00737 |     2.00748 |  0.00011 |   ops/s |
|                                                Max Throughput |                       composite-date_histogram-daily |     2.00918 |     2.00932 |  0.00013 |   ops/s |
|                                       50th percentile latency |                       composite-date_histogram-daily |     4.58136 |     4.26405 | -0.31731 |      ms |
|                                       90th percentile latency |                       composite-date_histogram-daily |     5.25791 |     4.59133 | -0.66658 |      ms |
|                                       99th percentile latency |                       composite-date_histogram-daily |     5.48104 |     4.74651 | -0.73454 |      ms |
|                                      100th percentile latency |                       composite-date_histogram-daily |     5.48555 |     4.77101 | -0.71453 |      ms |
|                                  50th percentile service time |                       composite-date_histogram-daily |     3.38121 |     2.97162 | -0.40959 |      ms |
|                                  90th percentile service time |                       composite-date_histogram-daily |     3.69266 |     3.10899 | -0.58366 |      ms |
|                                  99th percentile service time |                       composite-date_histogram-daily |     3.87137 |     3.37912 | -0.49226 |      ms |
|                                 100th percentile service time |                       composite-date_histogram-daily |     3.90057 |     3.39086 | -0.50971 |      ms |
|                                                    error rate |                       composite-date_histogram-daily |           0 |           0 |        0 |       % |
|                                                Min Throughput |                                                range |     2.00615 |     2.00651 |  0.00037 |   ops/s |
|                                               Mean Throughput |                                                range |     2.00745 |     2.00791 |  0.00045 |   ops/s |
|                                             Median Throughput |                                                range |     2.00735 |      2.0078 |  0.00045 |   ops/s |
|                                                Max Throughput |                                                range |     2.00915 |     2.00971 |  0.00056 |   ops/s |
|                                       50th percentile latency |                                                range |     18.0598 |     5.69891 | -12.3609 |      ms |
|                                       90th percentile latency |                                                range |     18.9776 |     6.13063 | -12.8469 |      ms |
|                                       99th percentile latency |                                                range |     22.3692 |     6.23498 | -16.1342 |      ms |
|                                      100th percentile latency |                                                range |     25.3216 |     6.24981 | -19.0718 |      ms |
|                                  50th percentile service time |                                                range |     16.9057 |     4.43809 | -12.4676 |      ms |
|                                  90th percentile service time |                                                range |      17.497 |     4.50149 | -12.9955 |      ms |
|                                  99th percentile service time |                                                range |      20.722 |     4.56258 | -16.1594 |      ms |
|                                 100th percentile service time |                                                range |     23.6264 |     4.56739 |  -19.059 |      ms |
|                                                    error rate |                                                range |           0 |           0 |        0 |       % |
|                                                Min Throughput |                                        range-numeric |     2.00657 |     2.00654 |   -2e-05 |   ops/s |
|                                               Mean Throughput |                                        range-numeric |     2.00797 |     2.00795 |   -2e-05 |   ops/s |
|                                             Median Throughput |                                        range-numeric |     2.00785 |     2.00784 |   -1e-05 |   ops/s |
|                                                Max Throughput |                                        range-numeric |      2.0098 |     2.00976 |   -3e-05 |   ops/s |
|                                       50th percentile latency |                                        range-numeric |     3.90754 |      3.8819 | -0.02564 |      ms |
|                                       90th percentile latency |                                        range-numeric |     4.33529 |      4.2958 | -0.03949 |      ms |
|                                       99th percentile latency |                                        range-numeric |     4.57196 |     4.56464 | -0.00731 |      ms |
|                                      100th percentile latency |                                        range-numeric |     4.61058 |      4.6401 |  0.02953 |      ms |
|                                  50th percentile service time |                                        range-numeric |     2.56346 |     2.59677 |   0.0333 |      ms |
|                                  90th percentile service time |                                        range-numeric |       2.778 |     2.69996 | -0.07804 |      ms |
|                                  99th percentile service time |                                        range-numeric |     3.02604 |     2.88843 |  -0.1376 |      ms |
|                                 100th percentile service time |                                        range-numeric |     3.04977 |     2.90659 | -0.14317 |      ms |
|                                                    error rate |                                        range-numeric |           0 |           0 |        0 |       % |
|                                                Min Throughput |                                     keyword-in-range |     2.00454 |     2.00415 | -0.00039 |   ops/s |
|                                               Mean Throughput |                                     keyword-in-range |     2.00552 |     2.00503 | -0.00048 |   ops/s |
|                                             Median Throughput |                                     keyword-in-range |     2.00545 |     2.00496 | -0.00049 |   ops/s |
|                                                Max Throughput |                                     keyword-in-range |     2.00677 |     2.00617 |  -0.0006 |   ops/s |
|                                       50th percentile latency |                                     keyword-in-range |     79.8613 |     58.3714 | -21.4899 |      ms |
|                                       90th percentile latency |                                     keyword-in-range |     80.8355 |     59.2045 |  -21.631 |      ms |
|                                       99th percentile latency |                                     keyword-in-range |     84.1485 |     61.6306 | -22.5179 |      ms |
|                                      100th percentile latency |                                     keyword-in-range |      85.457 |     63.1732 | -22.2838 |      ms |
|                                  50th percentile service time |                                     keyword-in-range |     78.6809 |     57.1088 | -21.5721 |      ms |
|                                  90th percentile service time |                                     keyword-in-range |     79.3926 |      57.874 | -21.5186 |      ms |
|                                  99th percentile service time |                                     keyword-in-range |     82.8264 |     60.4081 | -22.4183 |      ms |
|                                 100th percentile service time |                                     keyword-in-range |     83.7767 |     62.0774 | -21.6993 |      ms |
|                                                    error rate |                                     keyword-in-range |           0 |           0 |        0 |       % |
|                                                Min Throughput |                            date_histogram_hourly_agg |     2.00552 |     2.00553 |    2e-05 |   ops/s |
|                                               Mean Throughput |                            date_histogram_hourly_agg |     2.00669 |     2.00671 |    2e-05 |   ops/s |
|                                             Median Throughput |                            date_histogram_hourly_agg |      2.0066 |     2.00662 |    2e-05 |   ops/s |
|                                                Max Throughput |                            date_histogram_hourly_agg |     2.00821 |     2.00825 |    4e-05 |   ops/s |
|                                       50th percentile latency |                            date_histogram_hourly_agg |     9.13231 |     8.44707 | -0.68524 |      ms |
|                                       90th percentile latency |                            date_histogram_hourly_agg |     9.58899 |      8.8692 |  -0.7198 |      ms |
|                                       99th percentile latency |                            date_histogram_hourly_agg |     10.7747 |     9.35257 | -1.42217 |      ms |
|                                      100th percentile latency |                            date_histogram_hourly_agg |     11.6881 |     9.35772 | -2.33037 |      ms |
|                                  50th percentile service time |                            date_histogram_hourly_agg |     7.75839 |     7.14251 | -0.61587 |      ms |
|                                  90th percentile service time |                            date_histogram_hourly_agg |     8.05929 |     7.29874 | -0.76055 |      ms |
|                                  99th percentile service time |                            date_histogram_hourly_agg |     9.31462 |     7.66091 | -1.65371 |      ms |
|                                 100th percentile service time |                            date_histogram_hourly_agg |     10.3268 |     7.68337 |  -2.6434 |      ms |
|                                                    error rate |                            date_histogram_hourly_agg |           0 |           0 |        0 |       % |
|                                                Min Throughput |                            date_histogram_minute_agg |     2.00569 |     2.00572 |    3e-05 |   ops/s |
|                                               Mean Throughput |                            date_histogram_minute_agg |      2.0069 |     2.00694 |    4e-05 |   ops/s |
|                                             Median Throughput |                            date_histogram_minute_agg |     2.00681 |     2.00684 |    4e-05 |   ops/s |
|                                                Max Throughput |                            date_histogram_minute_agg |     2.00848 |     2.00851 |    3e-05 |   ops/s |
|                                       50th percentile latency |                            date_histogram_minute_agg |     41.1584 |     40.6714 | -0.48694 |      ms |
|                                       90th percentile latency |                            date_histogram_minute_agg |     41.8762 |      41.426 | -0.45017 |      ms |
|                                       99th percentile latency |                            date_histogram_minute_agg |     46.7947 |     45.7043 | -1.09042 |      ms |
|                                      100th percentile latency |                            date_histogram_minute_agg |     50.5103 |     48.2114 | -2.29889 |      ms |
|                                  50th percentile service time |                            date_histogram_minute_agg |     39.8841 |     39.3579 | -0.52622 |      ms |
|                                  90th percentile service time |                            date_histogram_minute_agg |     40.3686 |     40.0998 | -0.26884 |      ms |
|                                  99th percentile service time |                            date_histogram_minute_agg |     45.3955 |     44.5748 | -0.82072 |      ms |
|                                 100th percentile service time |                            date_histogram_minute_agg |      49.021 |     47.3376 | -1.68341 |      ms |
|                                                    error rate |                            date_histogram_minute_agg |           0 |           0 |        0 |       % |
|                                                Min Throughput |                                               scroll |     45.7253 |     49.9302 |  4.20494 | pages/s |
|                                               Mean Throughput |                                               scroll |     45.8368 |     49.9506 |  4.11376 | pages/s |
|                                             Median Throughput |                                               scroll |     45.8426 |     49.9519 |  4.10928 | pages/s |
|                                                Max Throughput |                                               scroll |     45.9435 |     49.9601 |   4.0166 | pages/s |
|                                       50th percentile latency |                                               scroll |     11716.3 |       474.4 | -11241.9 |      ms |
|                                       90th percentile latency |                                               scroll |     13252.5 |     492.603 | -12759.9 |      ms |
|                                       99th percentile latency |                                               scroll |       13582 |     527.337 | -13054.6 |      ms |
|                                      100th percentile latency |                                               scroll |     13600.7 |     527.458 | -13073.3 |      ms |
|                                  50th percentile service time |                                               scroll |     530.434 |     473.573 | -56.8611 |      ms |
|                                  90th percentile service time |                                               scroll |     535.154 |     488.858 | -46.2967 |      ms |
|                                  99th percentile service time |                                               scroll |     560.642 |     515.141 | -45.5014 |      ms |
|                                 100th percentile service time |                                               scroll |      566.37 |     523.024 | -43.3467 |      ms |
|                                                    error rate |                                               scroll |           0 |           0 |        0 |       % |
|                                                Min Throughput |                              query-string-on-message |     2.00608 |     2.00607 |   -1e-05 |   ops/s |
|                                               Mean Throughput |                              query-string-on-message |     2.00738 |     2.00736 |   -2e-05 |   ops/s |
|                                             Median Throughput |                              query-string-on-message |     2.00728 |     2.00726 |   -2e-05 |   ops/s |
|                                                Max Throughput |                              query-string-on-message |     2.00907 |     2.00905 |   -1e-05 |   ops/s |
|                                       50th percentile latency |                              query-string-on-message |     6.70187 |     6.56308 | -0.13879 |      ms |
|                                       90th percentile latency |                              query-string-on-message |      7.1605 |     6.85023 | -0.31027 |      ms |
|                                       99th percentile latency |                              query-string-on-message |     7.80913 |     7.27623 | -0.53291 |      ms |
|                                      100th percentile latency |                              query-string-on-message |     7.96633 |     7.46331 | -0.50302 |      ms |
|                                  50th percentile service time |                              query-string-on-message |     5.31549 |     5.12544 | -0.19005 |      ms |
|                                  90th percentile service time |                              query-string-on-message |     5.61404 |     5.27254 | -0.34149 |      ms |
|                                  99th percentile service time |                              query-string-on-message |      6.5282 |     5.91078 | -0.61742 |      ms |
|                                 100th percentile service time |                              query-string-on-message |     6.55518 |     6.30245 | -0.25272 |      ms |
|                                                    error rate |                              query-string-on-message |           0 |           0 |        0 |       % |
|                                                Min Throughput |                     query-string-on-message-filtered |     2.00579 |     2.00588 |   0.0001 |   ops/s |
|                                               Mean Throughput |                     query-string-on-message-filtered |     2.00702 |     2.00714 |  0.00012 |   ops/s |
|                                             Median Throughput |                     query-string-on-message-filtered |     2.00693 |     2.00704 |  0.00012 |   ops/s |
|                                                Max Throughput |                     query-string-on-message-filtered |     2.00863 |     2.00876 |  0.00013 |   ops/s |
|                                       50th percentile latency |                     query-string-on-message-filtered |     15.3821 |     13.6616 | -1.72042 |      ms |
|                                       90th percentile latency |                     query-string-on-message-filtered |     16.2081 |     14.1168 | -2.09127 |      ms |
|                                       99th percentile latency |                     query-string-on-message-filtered |     16.7847 |     16.5391 | -0.24562 |      ms |
|                                      100th percentile latency |                     query-string-on-message-filtered |       16.85 |     18.5841 |  1.73412 |      ms |
|                                  50th percentile service time |                     query-string-on-message-filtered |     14.2296 |      12.356 | -1.87364 |      ms |
|                                  90th percentile service time |                     query-string-on-message-filtered |     14.7216 |     12.5476 | -2.17399 |      ms |
|                                  99th percentile service time |                     query-string-on-message-filtered |     15.2554 |     15.1944 | -0.06099 |      ms |
|                                 100th percentile service time |                     query-string-on-message-filtered |     15.3829 |     17.5608 |  2.17787 |      ms |
|                                                    error rate |                     query-string-on-message-filtered |           0 |           0 |        0 |       % |
|                                                Min Throughput |          query-string-on-message-filtered-sorted-num |     2.00525 |     2.00554 |  0.00029 |   ops/s |
|                                               Mean Throughput |          query-string-on-message-filtered-sorted-num |     2.00636 |     2.00671 |  0.00034 |   ops/s |
|                                             Median Throughput |          query-string-on-message-filtered-sorted-num |     2.00628 |     2.00662 |  0.00034 |   ops/s |
|                                                Max Throughput |          query-string-on-message-filtered-sorted-num |     2.00781 |     2.00825 |  0.00043 |   ops/s |
|                                       50th percentile latency |          query-string-on-message-filtered-sorted-num |     33.4658 |     29.7827 | -3.68303 |      ms |
|                                       90th percentile latency |          query-string-on-message-filtered-sorted-num |     34.4646 |     30.3132 | -4.15133 |      ms |
|                                       99th percentile latency |          query-string-on-message-filtered-sorted-num |     35.3273 |     35.2908 | -0.03649 |      ms |
|                                      100th percentile latency |          query-string-on-message-filtered-sorted-num |     35.4716 |     35.7501 |  0.27854 |      ms |
|                                  50th percentile service time |          query-string-on-message-filtered-sorted-num |     32.2512 |     28.5028 | -3.74843 |      ms |
|                                  90th percentile service time |          query-string-on-message-filtered-sorted-num |     33.0584 |     29.0703 | -3.98818 |      ms |
|                                  99th percentile service time |          query-string-on-message-filtered-sorted-num |     33.8321 |     34.0893 |  0.25728 |      ms |
|                                 100th percentile service time |          query-string-on-message-filtered-sorted-num |     33.8634 |     34.3734 |  0.50997 |      ms |
|                                                    error rate |          query-string-on-message-filtered-sorted-num |           0 |           0 |        0 |       % |
|                                                Min Throughput |                      sort_keyword_can_match_shortcut |      2.0064 |     2.00645 |    5e-05 |   ops/s |
|                                               Mean Throughput |                      sort_keyword_can_match_shortcut |     2.00777 |     2.00782 |    5e-05 |   ops/s |
|                                             Median Throughput |                      sort_keyword_can_match_shortcut |     2.00767 |     2.00772 |    6e-05 |   ops/s |
|                                                Max Throughput |                      sort_keyword_can_match_shortcut |     2.00955 |      2.0096 |    5e-05 |   ops/s |
|                                       50th percentile latency |                      sort_keyword_can_match_shortcut |      6.1203 |     5.44101 | -0.67929 |      ms |
|                                       90th percentile latency |                      sort_keyword_can_match_shortcut |     6.69401 |     5.90336 | -0.79064 |      ms |
|                                       99th percentile latency |                      sort_keyword_can_match_shortcut |     7.17205 |     6.06663 | -1.10542 |      ms |
|                                      100th percentile latency |                      sort_keyword_can_match_shortcut |     7.26896 |     6.07683 | -1.19213 |      ms |
|                                  50th percentile service time |                      sort_keyword_can_match_shortcut |     4.93069 |     4.25123 | -0.67945 |      ms |
|                                  90th percentile service time |                      sort_keyword_can_match_shortcut |     5.18357 |     4.33295 | -0.85062 |      ms |
|                                  99th percentile service time |                      sort_keyword_can_match_shortcut |     5.50837 |     4.85899 | -0.64938 |      ms |
|                                 100th percentile service time |                      sort_keyword_can_match_shortcut |     5.68032 |     5.02462 |  -0.6557 |      ms |
|                                                    error rate |                      sort_keyword_can_match_shortcut |           0 |           0 |        0 |       % |
|                                                Min Throughput |                   sort_keyword_no_can_match_shortcut |     2.00655 |     2.00656 |    2e-05 |   ops/s |
|                                               Mean Throughput |                   sort_keyword_no_can_match_shortcut |     2.00794 |     2.00797 |    3e-05 |   ops/s |
|                                             Median Throughput |                   sort_keyword_no_can_match_shortcut |     2.00783 |     2.00786 |    4e-05 |   ops/s |
|                                                Max Throughput |                   sort_keyword_no_can_match_shortcut |     2.00976 |     2.00978 |    2e-05 |   ops/s |
|                                       50th percentile latency |                   sort_keyword_no_can_match_shortcut |     6.49512 |     5.66713 | -0.82799 |      ms |
|                                       90th percentile latency |                   sort_keyword_no_can_match_shortcut |     6.89408 |     6.05356 | -0.84052 |      ms |
|                                       99th percentile latency |                   sort_keyword_no_can_match_shortcut |     7.28779 |     6.15447 | -1.13332 |      ms |
|                                      100th percentile latency |                   sort_keyword_no_can_match_shortcut |     7.37737 |     6.19286 | -1.18451 |      ms |
|                                  50th percentile service time |                   sort_keyword_no_can_match_shortcut |     5.16424 |     4.32785 | -0.83638 |      ms |
|                                  90th percentile service time |                   sort_keyword_no_can_match_shortcut |     5.33843 |     4.40497 | -0.93346 |      ms |
|                                  99th percentile service time |                   sort_keyword_no_can_match_shortcut |     6.01186 |     4.73118 | -1.28068 |      ms |
|                                 100th percentile service time |                   sort_keyword_no_can_match_shortcut |     6.26155 |     4.97784 | -1.28371 |      ms |
|                                                    error rate |                   sort_keyword_no_can_match_shortcut |           0 |           0 |        0 |       % |
|                                                Min Throughput |                                    sort_numeric_desc |     2.00622 |      2.0063 |    8e-05 |   ops/s |
|                                               Mean Throughput |                                    sort_numeric_desc |     2.00755 |     2.00765 |   0.0001 |   ops/s |
|                                             Median Throughput |                                    sort_numeric_desc |     2.00745 |     2.00755 |   0.0001 |   ops/s |
|                                                Max Throughput |                                    sort_numeric_desc |     2.00927 |      2.0094 |  0.00013 |   ops/s |
|                                       50th percentile latency |                                    sort_numeric_desc |     6.73726 |     6.71916 | -0.01809 |      ms |
|                                       90th percentile latency |                                    sort_numeric_desc |      7.1403 |     7.07773 | -0.06257 |      ms |
|                                       99th percentile latency |                                    sort_numeric_desc |     7.54057 |     7.56936 |  0.02879 |      ms |
|                                      100th percentile latency |                                    sort_numeric_desc |     7.54767 |     7.82342 |  0.27575 |      ms |
|                                  50th percentile service time |                                    sort_numeric_desc |     5.39905 |     5.45731 |  0.05826 |      ms |
|                                  90th percentile service time |                                    sort_numeric_desc |     5.67091 |     5.53969 | -0.13122 |      ms |
|                                  99th percentile service time |                                    sort_numeric_desc |     6.02725 |      5.8956 | -0.13165 |      ms |
|                                 100th percentile service time |                                    sort_numeric_desc |     6.04497 |     6.09782 |  0.05285 |      ms |
|                                                    error rate |                                    sort_numeric_desc |           0 |           0 |        0 |       % |
|                                                Min Throughput |                                     sort_numeric_asc |     2.00653 |     2.00656 |    3e-05 |   ops/s |
|                                               Mean Throughput |                                     sort_numeric_asc |     2.00793 |     2.00796 |    2e-05 |   ops/s |
|                                             Median Throughput |                                     sort_numeric_asc |     2.00783 |     2.00785 |    3e-05 |   ops/s |
|                                                Max Throughput |                                     sort_numeric_asc |     2.00975 |     2.00978 |    3e-05 |   ops/s |
|                                       50th percentile latency |                                     sort_numeric_asc |     6.24194 |     5.73872 | -0.50322 |      ms |
|                                       90th percentile latency |                                     sort_numeric_asc |     6.70987 |     6.12636 | -0.58351 |      ms |
|                                       99th percentile latency |                                     sort_numeric_asc |      7.0216 |     6.87171 | -0.14989 |      ms |
|                                      100th percentile latency |                                     sort_numeric_asc |     7.04001 |     6.98314 | -0.05688 |      ms |
|                                  50th percentile service time |                                     sort_numeric_asc |      4.9881 |     4.44547 | -0.54263 |      ms |
|                                  90th percentile service time |                                     sort_numeric_asc |     5.17044 |     4.51035 | -0.66009 |      ms |
|                                  99th percentile service time |                                     sort_numeric_asc |      5.2903 |     4.56265 | -0.72765 |      ms |
|                                 100th percentile service time |                                     sort_numeric_asc |     5.32683 |     4.57383 |   -0.753 |      ms |
|                                                    error rate |                                     sort_numeric_asc |           0 |           0 |        0 |       % |
|                                                Min Throughput |                         sort_numeric_desc_with_match |     2.00655 |     2.00655 |        0 |   ops/s |
|                                               Mean Throughput |                         sort_numeric_desc_with_match |     2.00794 |     2.00795 |    1e-05 |   ops/s |
|                                             Median Throughput |                         sort_numeric_desc_with_match |     2.00783 |     2.00784 |    1e-05 |   ops/s |
|                                                Max Throughput |                         sort_numeric_desc_with_match |     2.00975 |     2.00977 |    2e-05 |   ops/s |
|                                       50th percentile latency |                         sort_numeric_desc_with_match |     4.18638 |      4.0699 | -0.11648 |      ms |
|                                       90th percentile latency |                         sort_numeric_desc_with_match |     4.60582 |     4.44637 | -0.15945 |      ms |
|                                       99th percentile latency |                         sort_numeric_desc_with_match |     4.81055 |     4.66456 |   -0.146 |      ms |
|                                      100th percentile latency |                         sort_numeric_desc_with_match |     4.81957 |      4.6777 | -0.14188 |      ms |
|                                  50th percentile service time |                         sort_numeric_desc_with_match |     2.88243 |     2.81628 | -0.06615 |      ms |
|                                  90th percentile service time |                         sort_numeric_desc_with_match |     3.05893 |     2.87464 |  -0.1843 |      ms |
|                                  99th percentile service time |                         sort_numeric_desc_with_match |     3.13729 |     2.96952 | -0.16777 |      ms |
|                                 100th percentile service time |                         sort_numeric_desc_with_match |     3.13944 |     2.99504 |  -0.1444 |      ms |
|                                                    error rate |                         sort_numeric_desc_with_match |           0 |           0 |        0 |       % |
|                                                Min Throughput |                          sort_numeric_asc_with_match |      2.0066 |     2.00659 |   -1e-05 |   ops/s |
|                                               Mean Throughput |                          sort_numeric_asc_with_match |       2.008 |     2.00799 |   -1e-05 |   ops/s |
|                                             Median Throughput |                          sort_numeric_asc_with_match |     2.00789 |     2.00788 |       -0 |   ops/s |
|                                                Max Throughput |                          sort_numeric_asc_with_match |     2.00983 |     2.00982 |   -1e-05 |   ops/s |
|                                       50th percentile latency |                          sort_numeric_asc_with_match |     3.69023 |     4.03045 |  0.34022 |      ms |
|                                       90th percentile latency |                          sort_numeric_asc_with_match |     4.13814 |     4.44824 |   0.3101 |      ms |
|                                       99th percentile latency |                          sort_numeric_asc_with_match |     4.23779 |     6.07423 |  1.83644 |      ms |
|                                      100th percentile latency |                          sort_numeric_asc_with_match |     4.24206 |     7.44716 |   3.2051 |      ms |
|                                  50th percentile service time |                          sort_numeric_asc_with_match |     2.44725 |     2.73881 |  0.29156 |      ms |
|                                  90th percentile service time |                          sort_numeric_asc_with_match |     2.59958 |     2.80791 |  0.20834 |      ms |
|                                  99th percentile service time |                          sort_numeric_asc_with_match |     2.72489 |     4.39589 |  1.67101 |      ms |
|                                 100th percentile service time |                          sort_numeric_asc_with_match |     2.73182 |     5.81636 |  3.08455 |      ms |
|                                                    error rate |                          sort_numeric_asc_with_match |           0 |           0 |        0 |       % |
|                                                Min Throughput |     range_field_conjunction_big_range_big_term_query |     2.00658 |     2.00658 |        0 |   ops/s |
|                                               Mean Throughput |     range_field_conjunction_big_range_big_term_query |     2.00799 |     2.00798 |   -1e-05 |   ops/s |
|                                             Median Throughput |     range_field_conjunction_big_range_big_term_query |     2.00788 |     2.00787 |   -1e-05 |   ops/s |
|                                                Max Throughput |     range_field_conjunction_big_range_big_term_query |      2.0098 |      2.0098 |       -0 |   ops/s |
|                                       50th percentile latency |     range_field_conjunction_big_range_big_term_query |     3.78824 |     4.07563 |  0.28738 |      ms |
|                                       90th percentile latency |     range_field_conjunction_big_range_big_term_query |     4.20383 |     4.46296 |  0.25913 |      ms |
|                                       99th percentile latency |     range_field_conjunction_big_range_big_term_query |     4.40788 |      4.5549 |  0.14702 |      ms |
|                                      100th percentile latency |     range_field_conjunction_big_range_big_term_query |     4.48139 |     4.59306 |  0.11167 |      ms |
|                                  50th percentile service time |     range_field_conjunction_big_range_big_term_query |     2.47859 |     2.72751 |  0.24892 |      ms |
|                                  90th percentile service time |     range_field_conjunction_big_range_big_term_query |     2.61558 |     2.81156 |  0.19598 |      ms |
|                                  99th percentile service time |     range_field_conjunction_big_range_big_term_query |     2.74816 |     2.86617 |  0.11802 |      ms |
|                                 100th percentile service time |     range_field_conjunction_big_range_big_term_query |     2.74931 |     2.87729 |  0.12798 |      ms |
|                                                    error rate |     range_field_conjunction_big_range_big_term_query |           0 |           0 |        0 |       % |
|                                                Min Throughput |   range_field_disjunction_big_range_small_term_query |     2.00654 |     2.00656 |    2e-05 |   ops/s |
|                                               Mean Throughput |   range_field_disjunction_big_range_small_term_query |     2.00794 |     2.00795 |    1e-05 |   ops/s |
|                                             Median Throughput |   range_field_disjunction_big_range_small_term_query |     2.00783 |     2.00785 |    1e-05 |   ops/s |
|                                                Max Throughput |   range_field_disjunction_big_range_small_term_query |     2.00976 |     2.00977 |    1e-05 |   ops/s |
|                                       50th percentile latency |   range_field_disjunction_big_range_small_term_query |      3.9765 |      3.6293 |  -0.3472 |      ms |
|                                       90th percentile latency |   range_field_disjunction_big_range_small_term_query |     4.43615 |     4.10674 | -0.32941 |      ms |
|                                       99th percentile latency |   range_field_disjunction_big_range_small_term_query |     5.18007 |     4.24425 | -0.93582 |      ms |
|                                      100th percentile latency |   range_field_disjunction_big_range_small_term_query |     5.56564 |     4.24948 | -1.31616 |      ms |
|                                  50th percentile service time |   range_field_disjunction_big_range_small_term_query |     2.67163 |     2.41732 | -0.25431 |      ms |
|                                  90th percentile service time |   range_field_disjunction_big_range_small_term_query |     2.86584 |     2.47915 | -0.38669 |      ms |
|                                  99th percentile service time |   range_field_disjunction_big_range_small_term_query |      3.8332 |     2.58003 | -1.25318 |      ms |
|                                 100th percentile service time |   range_field_disjunction_big_range_small_term_query |       4.581 |     2.60652 | -1.97447 |      ms |
|                                                    error rate |   range_field_disjunction_big_range_small_term_query |           0 |           0 |        0 |       % |
|                                                Min Throughput | range_field_conjunction_small_range_small_term_query |     2.00659 |     2.00659 |   -1e-05 |   ops/s |
|                                               Mean Throughput | range_field_conjunction_small_range_small_term_query |       2.008 |     2.00799 |   -1e-05 |   ops/s |
|                                             Median Throughput | range_field_conjunction_small_range_small_term_query |     2.00789 |     2.00789 |   -1e-05 |   ops/s |
|                                                Max Throughput | range_field_conjunction_small_range_small_term_query |     2.00982 |     2.00982 |        0 |   ops/s |
|                                       50th percentile latency | range_field_conjunction_small_range_small_term_query |     3.80264 |     3.86326 |  0.06062 |      ms |
|                                       90th percentile latency | range_field_conjunction_small_range_small_term_query |     4.19813 |     4.31881 |  0.12068 |      ms |
|                                       99th percentile latency | range_field_conjunction_small_range_small_term_query |     4.34255 |     4.47051 |  0.12796 |      ms |
|                                      100th percentile latency | range_field_conjunction_small_range_small_term_query |     4.34531 |      4.5248 |  0.17949 |      ms |
|                                  50th percentile service time | range_field_conjunction_small_range_small_term_query |      2.4698 |     2.58415 |  0.11435 |      ms |
|                                  90th percentile service time | range_field_conjunction_small_range_small_term_query |     2.67121 |     2.65819 | -0.01302 |      ms |
|                                  99th percentile service time | range_field_conjunction_small_range_small_term_query |     2.83774 |     2.74241 | -0.09533 |      ms |
|                                 100th percentile service time | range_field_conjunction_small_range_small_term_query |     2.85178 |     2.78363 | -0.06815 |      ms |
|                                                    error rate | range_field_conjunction_small_range_small_term_query |           0 |           0 |        0 |       % |
|                                                Min Throughput |   range_field_conjunction_small_range_big_term_query |     2.00657 |     2.00659 |    2e-05 |   ops/s |
|                                               Mean Throughput |   range_field_conjunction_small_range_big_term_query |     2.00798 |       2.008 |    2e-05 |   ops/s |
|                                             Median Throughput |   range_field_conjunction_small_range_big_term_query |     2.00787 |     2.00789 |    2e-05 |   ops/s |
|                                                Max Throughput |   range_field_conjunction_small_range_big_term_query |     2.00979 |     2.00982 |    3e-05 |   ops/s |
|                                       50th percentile latency |   range_field_conjunction_small_range_big_term_query |     4.08656 |     3.65862 | -0.42794 |      ms |
|                                       90th percentile latency |   range_field_conjunction_small_range_big_term_query |     4.50322 |     4.00879 | -0.49442 |      ms |
|                                       99th percentile latency |   range_field_conjunction_small_range_big_term_query |       4.715 |     4.25084 | -0.46416 |      ms |
|                                      100th percentile latency |   range_field_conjunction_small_range_big_term_query |     4.76233 |     4.30381 | -0.45852 |      ms |
|                                  50th percentile service time |   range_field_conjunction_small_range_big_term_query |     2.72506 |     2.34114 | -0.38392 |      ms |
|                                  90th percentile service time |   range_field_conjunction_small_range_big_term_query |     2.86318 |      2.4178 | -0.44538 |      ms |
|                                  99th percentile service time |   range_field_conjunction_small_range_big_term_query |     3.18496 |      2.4834 | -0.70156 |      ms |
|                                 100th percentile service time |   range_field_conjunction_small_range_big_term_query |     3.38319 |     2.49839 | -0.88479 |      ms |
|                                                    error rate |   range_field_conjunction_small_range_big_term_query |           0 |           0 |        0 |       % |
|                                                Min Throughput |                                range-auto-date-histo |    0.110808 |    0.110562 | -0.00025 |   ops/s |
|                                               Mean Throughput |                                range-auto-date-histo |     0.11086 |    0.110734 | -0.00013 |   ops/s |
|                                             Median Throughput |                                range-auto-date-histo |    0.110862 |     0.11066 |  -0.0002 |   ops/s |
|                                                Max Throughput |                                range-auto-date-histo |    0.110922 |     0.11107 |  0.00015 |   ops/s |
|                                       50th percentile latency |                                range-auto-date-histo | 2.13465e+06 | 2.13925e+06 |  4596.75 |      ms |
|                                       90th percentile latency |                                range-auto-date-histo | 2.47432e+06 | 2.47186e+06 | -2462.38 |      ms |
|                                       99th percentile latency |                                range-auto-date-histo | 2.55096e+06 | 2.54675e+06 | -4205.75 |      ms |
|                                      100th percentile latency |                                range-auto-date-histo |  2.5552e+06 |  2.5509e+06 | -4296.25 |      ms |
|                                  50th percentile service time |                                range-auto-date-histo |     8971.03 |        8904 | -67.0269 |      ms |
|                                  90th percentile service time |                                range-auto-date-histo |     9126.98 |     9109.89 | -17.0855 |      ms |
|                                  99th percentile service time |                                range-auto-date-histo |     9299.01 |     9263.96 | -35.0503 |      ms |
|                                 100th percentile service time |                                range-auto-date-histo |     9314.15 |     9265.77 |  -48.377 |      ms |
|                                                    error rate |                                range-auto-date-histo |           0 |           0 |        0 |       % |
|                                                Min Throughput |                   range-auto-date-histo-with-metrics |   0.0440366 |   0.0451728 |  0.00114 |   ops/s |
|                                               Mean Throughput |                   range-auto-date-histo-with-metrics |   0.0440445 |   0.0452877 |  0.00124 |   ops/s |
|                                             Median Throughput |                   range-auto-date-histo-with-metrics |   0.0440438 |   0.0452885 |  0.00124 |   ops/s |
|                                                Max Throughput |                   range-auto-date-histo-with-metrics |   0.0440525 |   0.0453971 |  0.00134 |   ops/s |
|                                       50th percentile latency |                   range-auto-date-histo-with-metrics | 5.56287e+06 | 5.40729e+06 |  -155578 |      ms |
|                                       90th percentile latency |                   range-auto-date-histo-with-metrics | 6.45024e+06 |   6.284e+06 |  -166242 |      ms |
|                                       99th percentile latency |                   range-auto-date-histo-with-metrics | 6.64998e+06 | 6.48165e+06 |  -168328 |      ms |
|                                      100th percentile latency |                   range-auto-date-histo-with-metrics | 6.66111e+06 | 6.49266e+06 |  -168449 |      ms |
|                                  50th percentile service time |                   range-auto-date-histo-with-metrics |     22665.3 |     22396.9 | -268.354 |      ms |
|                                  90th percentile service time |                   range-auto-date-histo-with-metrics |     22836.1 |     22549.7 |  -286.45 |      ms |
|                                  99th percentile service time |                   range-auto-date-histo-with-metrics |     23089.2 |     22677.5 |  -411.69 |      ms |
|                                 100th percentile service time |                   range-auto-date-histo-with-metrics |     23112.8 |     22698.3 | -414.521 |      ms |
|                                                    error rate |                   range-auto-date-histo-with-metrics |           0 |           0 |        0 |       % |
|                                                Min Throughput |                                          range-agg-1 |     2.00653 |     2.00653 |    1e-05 |   ops/s |
|                                               Mean Throughput |                                          range-agg-1 |     2.00792 |     2.00793 |    1e-05 |   ops/s |
|                                             Median Throughput |                                          range-agg-1 |     2.00781 |     2.00783 |    2e-05 |   ops/s |
|                                                Max Throughput |                                          range-agg-1 |     2.00973 |     2.00974 |    2e-05 |   ops/s |
|                                       50th percentile latency |                                          range-agg-1 |     4.29684 |     3.85546 | -0.44138 |      ms |
|                                       90th percentile latency |                                          range-agg-1 |     4.66024 |     4.25129 | -0.40895 |      ms |
|                                       99th percentile latency |                                          range-agg-1 |     4.86146 |     4.43828 | -0.42319 |      ms |
|                                      100th percentile latency |                                          range-agg-1 |     4.92675 |     4.45281 | -0.47393 |      ms |
|                                  50th percentile service time |                                          range-agg-1 |     2.85252 |     2.54375 | -0.30878 |      ms |
|                                  90th percentile service time |                                          range-agg-1 |     3.06547 |     2.63262 | -0.43284 |      ms |
|                                  99th percentile service time |                                          range-agg-1 |     3.23114 |     2.77577 | -0.45536 |      ms |
|                                 100th percentile service time |                                          range-agg-1 |     3.23498 |     2.86534 | -0.36963 |      ms |
|                                                    error rate |                                          range-agg-1 |           0 |           0 |        0 |       % |
|                                                Min Throughput |                                          range-agg-2 |     2.00659 |     2.00658 |       -0 |   ops/s |
|                                               Mean Throughput |                                          range-agg-2 |       2.008 |     2.00798 |   -1e-05 |   ops/s |
|                                             Median Throughput |                                          range-agg-2 |     2.00789 |     2.00788 |   -1e-05 |   ops/s |
|                                                Max Throughput |                                          range-agg-2 |     2.00981 |     2.00981 |       -0 |   ops/s |
|                                       50th percentile latency |                                          range-agg-2 |      4.0475 |     4.14894 |  0.10144 |      ms |
|                                       90th percentile latency |                                          range-agg-2 |     4.44889 |     4.62475 |  0.17586 |      ms |
|                                       99th percentile latency |                                          range-agg-2 |     5.06021 |     4.79056 | -0.26965 |      ms |
|                                      100th percentile latency |                                          range-agg-2 |     5.13023 |     4.79911 | -0.33112 |      ms |
|                                  50th percentile service time |                                          range-agg-2 |     2.67692 |     2.92558 |  0.24867 |      ms |
|                                  90th percentile service time |                                          range-agg-2 |      2.8615 |     3.04502 |  0.18352 |      ms |
|                                  99th percentile service time |                                          range-agg-2 |     3.13258 |     3.18081 |  0.04823 |      ms |
|                                 100th percentile service time |                                          range-agg-2 |     3.13569 |     3.22458 |  0.08889 |      ms |
|                                                    error rate |                                          range-agg-2 |           0 |           0 |        0 |       % |
|                                                Min Throughput |                                  cardinality-agg-low |     2.00634 |     2.00638 |    4e-05 |   ops/s |
|                                               Mean Throughput |                                  cardinality-agg-low |     2.00769 |     2.00773 |    5e-05 |   ops/s |
|                                             Median Throughput |                                  cardinality-agg-low |     2.00758 |     2.00763 |    6e-05 |   ops/s |
|                                                Max Throughput |                                  cardinality-agg-low |     2.00945 |     2.00949 |    4e-05 |   ops/s |
|                                       50th percentile latency |                                  cardinality-agg-low |     5.88695 |     5.35886 | -0.52808 |      ms |
|                                       90th percentile latency |                                  cardinality-agg-low |     6.33219 |     5.81251 | -0.51968 |      ms |
|                                       99th percentile latency |                                  cardinality-agg-low |     6.71844 |     5.92569 | -0.79275 |      ms |
|                                      100th percentile latency |                                  cardinality-agg-low |      6.9011 |     5.93762 | -0.96348 |      ms |
|                                  50th percentile service time |                                  cardinality-agg-low |     4.58953 |     4.12306 | -0.46648 |      ms |
|                                  90th percentile service time |                                  cardinality-agg-low |     4.82851 |     4.19725 | -0.63126 |      ms |
|                                  99th percentile service time |                                  cardinality-agg-low |     5.14203 |     4.28697 | -0.85506 |      ms |
|                                 100th percentile service time |                                  cardinality-agg-low |     5.20205 |     4.29233 | -0.90972 |      ms |
|                                                    error rate |                                  cardinality-agg-low |           0 |           0 |        0 |       % |
|                                                Min Throughput |                                 cardinality-agg-high |    0.409017 |    0.395954 | -0.01306 |   ops/s |
|                                               Mean Throughput |                                 cardinality-agg-high |    0.409127 |    0.396166 | -0.01296 |   ops/s |
|                                             Median Throughput |                                 cardinality-agg-high |     0.40913 |     0.39617 | -0.01296 |   ops/s |
|                                                Max Throughput |                                 cardinality-agg-high |    0.409225 |    0.396389 | -0.01284 |   ops/s |
|                                       50th percentile latency |                                 cardinality-agg-high |      487501 |      507512 |  20011.2 |      ms |
|                                       90th percentile latency |                                 cardinality-agg-high |      565222 |      588556 |  23334.6 |      ms |
|                                       99th percentile latency |                                 cardinality-agg-high |      582641 |      606557 |  23915.8 |      ms |
|                                      100th percentile latency |                                 cardinality-agg-high |      583606 |      607600 |  23994.2 |      ms |
|                                  50th percentile service time |                                 cardinality-agg-high |     2429.64 |     2516.06 |  86.4191 |      ms |
|                                  90th percentile service time |                                 cardinality-agg-high |      2505.8 |     2585.76 |  79.9624 |      ms |
|                                  99th percentile service time |                                 cardinality-agg-high |     2562.17 |     2628.52 |  66.3556 |      ms |
|                                 100th percentile service time |                                 cardinality-agg-high |     2574.12 |     2632.61 |  58.4895 |      ms |
|                                                    error rate |                                 cardinality-agg-high |           0 |           0 |        0 |       % |
</details>

author_association: COLLABORATOR
user: login: github-actions[bot]
created_at: 2025-04-07T18:02:45Z
body: :x: Gradle check result for d4a6a8659b90e66a2efa5b99f849015bc5b6a506: [FAILURE](https://build.ci.opensearch.org/job/gradle-check/55746/)

Please examine the workflow log, locate, and copy-paste the failure(s) below, then iterate to green. Is the failure [a flaky test](https://github.com/opensearch-project/OpenSearch/blob/main/DEVELOPER_GUIDE.md#flaky-tests) unrelated to your change?
author_association: CONTRIBUTOR
user: login: github-actions[bot]
created_at: 2025-04-07T18:30:53Z
body: :x: Gradle check result for d4a6a8659b90e66a2efa5b99f849015bc5b6a506: [FAILURE](https://build.ci.opensearch.org/job/gradle-check/55755/)

Please examine the workflow log, locate, and copy-paste the failure(s) below, then iterate to green. Is the failure [a flaky test](https://github.com/opensearch-project/OpenSearch/blob/main/DEVELOPER_GUIDE.md#flaky-tests) unrelated to your change?
author_association: CONTRIBUTOR
user: login: harshavamsi
created_at: 2025-04-07T18:56:00Z
body: [org.opensearch.repositories.s3.S3BlobContainerRetriesTests.classMethod](https://build.ci.opensearch.org/job/gradle-check/55755/testReport/junit/org.opensearch.repositories.s3/S3BlobContainerRetriesTests/classMethod/)
    [org.opensearch.repositories.s3.S3BlobContainerRetriesTests.classMethod](https://build.ci.opensearch.org/job/gradle-check/55755/testReport/junit/org.opensearch.repositories.s3/S3BlobContainerRetriesTests/classMethod_2/)
    
    Flaky tests

@msfroh can we re-run gradle check, it was green previously and no code changes
author_association: CONTRIBUTOR
user: login: github-actions[bot]
created_at: 2025-04-07T19:52:57Z
body: :x: Gradle check result for d4a6a8659b90e66a2efa5b99f849015bc5b6a506: [FAILURE](https://build.ci.opensearch.org/job/gradle-check/55758/)

Please examine the workflow log, locate, and copy-paste the failure(s) below, then iterate to green. Is the failure [a flaky test](https://github.com/opensearch-project/OpenSearch/blob/main/DEVELOPER_GUIDE.md#flaky-tests) unrelated to your change?
author_association: CONTRIBUTOR
user: login: harshavamsi
created_at: 2025-04-08T22:04:39Z
body: @msfroh can we run gradle check again?
author_association: CONTRIBUTOR
user: login: github-actions[bot]
created_at: 2025-04-09T00:15:12Z
body: :x: Gradle check result for d4a6a8659b90e66a2efa5b99f849015bc5b6a506: [FAILURE](https://build.ci.opensearch.org/job/gradle-check/55917/)

Please examine the workflow log, locate, and copy-paste the failure(s) below, then iterate to green. Is the failure [a flaky test](https://github.com/opensearch-project/OpenSearch/blob/main/DEVELOPER_GUIDE.md#flaky-tests) unrelated to your change?
author_association: CONTRIBUTOR
user: login: github-actions[bot]
created_at: 2025-04-09T02:04:13Z
body: :grey_exclamation: Gradle check result for d4a6a8659b90e66a2efa5b99f849015bc5b6a506: [UNSTABLE](https://build.ci.opensearch.org/job/gradle-check/55924/) 

Please review all [flaky tests](https://github.com/opensearch-project/OpenSearch/blob/main/DEVELOPER_GUIDE.md#flaky-tests) that succeeded after retry and create an issue if one does not already exist to track the flaky failure.
author_association: CONTRIBUTOR
user: login: github-actions[bot]
created_at: 2025-04-09T05:41:31Z
body: :x: Gradle check result for 33f19ec228d0969cecaf83f8bc67bd8d057d2aa6: [FAILURE](https://build.ci.opensearch.org/job/gradle-check/55946/)

Please examine the workflow log, locate, and copy-paste the failure(s) below, then iterate to green. Is the failure [a flaky test](https://github.com/opensearch-project/OpenSearch/blob/main/DEVELOPER_GUIDE.md#flaky-tests) unrelated to your change?
author_association: CONTRIBUTOR
user: login: github-actions[bot]
created_at: 2025-04-09T16:08:43Z
body: :x: Gradle check result for 3534c2683f189d0a711dbb99e1d120cabc653c36: [FAILURE](https://build.ci.opensearch.org/job/gradle-check/55967/)

Please examine the workflow log, locate, and copy-paste the failure(s) below, then iterate to green. Is the failure [a flaky test](https://github.com/opensearch-project/OpenSearch/blob/main/DEVELOPER_GUIDE.md#flaky-tests) unrelated to your change?
author_association: CONTRIBUTOR
user: login: github-actions[bot]
created_at: 2025-04-09T17:16:24Z
body: :x: Gradle check result for 831376c709b5b622d69f1c133dc2a7d4a439b3a6: [FAILURE](https://build.ci.opensearch.org/job/gradle-check/55971/)

Please examine the workflow log, locate, and copy-paste the failure(s) below, then iterate to green. Is the failure [a flaky test](https://github.com/opensearch-project/OpenSearch/blob/main/DEVELOPER_GUIDE.md#flaky-tests) unrelated to your change?
author_association: CONTRIBUTOR
user: login: github-actions[bot]
created_at: 2025-04-09T18:55:17Z
body: :x: Gradle check result for 831376c709b5b622d69f1c133dc2a7d4a439b3a6: [FAILURE](https://build.ci.opensearch.org/job/gradle-check/55988/)

Please examine the workflow log, locate, and copy-paste the failure(s) below, then iterate to green. Is the failure [a flaky test](https://github.com/opensearch-project/OpenSearch/blob/main/DEVELOPER_GUIDE.md#flaky-tests) unrelated to your change?
author_association: CONTRIBUTOR
user: login: github-actions[bot]
created_at: 2025-04-09T20:22:20Z
body: :x: Gradle check result for 831376c709b5b622d69f1c133dc2a7d4a439b3a6: [FAILURE](https://build.ci.opensearch.org/job/gradle-check/55991/)

Please examine the workflow log, locate, and copy-paste the failure(s) below, then iterate to green. Is the failure [a flaky test](https://github.com/opensearch-project/OpenSearch/blob/main/DEVELOPER_GUIDE.md#flaky-tests) unrelated to your change?
author_association: CONTRIBUTOR
user: login: github-actions[bot]
created_at: 2025-04-09T21:38:58Z
body: :white_check_mark: Gradle check result for 831376c709b5b622d69f1c133dc2a7d4a439b3a6: [SUCCESS](https://build.ci.opensearch.org/job/gradle-check/56003/)
author_association: CONTRIBUTOR