From 5c5f1d14d78e0ab37fbc8786581b2c5088373837 Mon Sep 17 00:00:00 2001 From: Jordan Powers Date: Thu, 20 Nov 2025 08:38:19 -0800 Subject: [PATCH 1/3] Add MappingParsingBenchmark --- benchmarks/build.gradle | 1 + .../common/MappingParsingBenchmark.java | 173 ++++++++++++++++++ 2 files changed, 174 insertions(+) create mode 100644 benchmarks/src/main/java/org/elasticsearch/benchmark/indices/common/MappingParsingBenchmark.java diff --git a/benchmarks/build.gradle b/benchmarks/build.gradle index 93a8797cccbae..dcb63e74dcfcf 100644 --- a/benchmarks/build.gradle +++ b/benchmarks/build.gradle @@ -48,6 +48,7 @@ dependencies { api(project(':x-pack:plugin:esql')) api(project(':x-pack:plugin:esql:compute')) api(project(':x-pack:plugin:mapper-exponential-histogram')) + api(project(':x-pack:plugin:logsdb')) implementation project(path: ':libs:native') implementation project(path: ':libs:simdvec') implementation project(path: ':libs:exponential-histogram') diff --git a/benchmarks/src/main/java/org/elasticsearch/benchmark/indices/common/MappingParsingBenchmark.java b/benchmarks/src/main/java/org/elasticsearch/benchmark/indices/common/MappingParsingBenchmark.java new file mode 100644 index 0000000000000..13e8b7f861d13 --- /dev/null +++ b/benchmarks/src/main/java/org/elasticsearch/benchmark/indices/common/MappingParsingBenchmark.java @@ -0,0 +1,173 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the "Elastic License + * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side + * Public License v 1"; you may not use this file except in compliance with, at + * your election, the "Elastic License 2.0", the "GNU Affero General Public + * License v3.0 only", or the "Server Side Public License, v 1". + */ + +package org.elasticsearch.benchmark.indices.common; + +import org.elasticsearch.TransportVersion; +import org.elasticsearch.cluster.ClusterModule; +import org.elasticsearch.cluster.metadata.IndexMetadata; +import org.elasticsearch.common.compress.CompressedXContent; +import org.elasticsearch.common.logging.LogConfigurator; +import org.elasticsearch.common.settings.IndexScopedSettings; +import org.elasticsearch.common.settings.Setting; +import org.elasticsearch.common.settings.Settings; +import org.elasticsearch.common.xcontent.LoggingDeprecationHandler; +import org.elasticsearch.index.IndexSettings; +import org.elasticsearch.index.IndexVersion; +import org.elasticsearch.index.analysis.IndexAnalyzers; +import org.elasticsearch.index.cache.bitset.BitsetFilterCache; +import org.elasticsearch.index.mapper.MapperMetrics; +import org.elasticsearch.index.mapper.MapperRegistry; +import org.elasticsearch.index.mapper.MapperService; +import org.elasticsearch.index.mapper.ProvidedIdFieldMapper; +import org.elasticsearch.index.similarity.SimilarityService; +import org.elasticsearch.indices.IndicesModule; +import org.elasticsearch.script.Script; +import org.elasticsearch.script.ScriptCompiler; +import org.elasticsearch.script.ScriptContext; +import org.elasticsearch.xcontent.NamedXContentRegistry; +import org.elasticsearch.xcontent.XContentParserConfiguration; +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Fork; +import org.openjdk.jmh.annotations.Measurement; +import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Param; +import org.openjdk.jmh.annotations.Scope; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.annotations.State; +import org.openjdk.jmh.annotations.Warmup; + +import org.elasticsearch.xpack.logsdb.LogsDBPlugin; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Random; +import java.util.Set; +import java.util.concurrent.TimeUnit; + +@Fork(value = 1) +@Warmup(iterations = 2) +@Measurement(iterations = 5) +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MILLISECONDS) +@State(Scope.Benchmark) +public class MappingParsingBenchmark { + static { + // For Elasticsearch900Lucene101Codec: + LogConfigurator.loadLog4jPlugins(); + LogConfigurator.configureESLogging(); + LogConfigurator.setNodeName("test"); + } + + private static final String MAPPING = """ + { + "_doc": { + "dynamic": false, + "properties": { + "@timestamp": { + "type": "date" + }, + "host": { + "type": "object", + "properties": { + "name": { + "type": "keyword" + } + } + }, + "message": { + "type": "pattern_text" + } + } + } + } + \s"""; + + @Param("1024") + private int numIndices; + + private List mapperServices; + private CompressedXContent compressedMapping; + + private Random random = new Random(); + private static final String CHARS = "abcdefghijklmnopqrstuvwxyz1234567890"; + + private String randomIndexName() { + StringBuilder b = new StringBuilder(); + for (int i = 0; i < 10; i++) { + b.append(CHARS.charAt(random.nextInt(CHARS.length()))); + } + return b.toString(); + } + + @Setup + public void setUp() throws IOException { + Settings settings = Settings.builder() + .put("index.number_of_replicas", 0) + .put("index.number_of_shards", 1) + .put(IndexMetadata.SETTING_VERSION_CREATED, IndexVersion.current()) + .put("index.mode", "logsdb") + .put("index.logsdb.sort_on_host_name", true) + .put("index.logsdb.sort_on_message_template", true) + .build(); + + LogsDBPlugin logsDBPlugin = new LogsDBPlugin(settings); + + Set> definedSettings = new HashSet<>(IndexScopedSettings.BUILT_IN_INDEX_SETTINGS); + definedSettings.addAll(logsDBPlugin.getSettings().stream().filter(Setting::hasIndexScope).toList()); + IndexScopedSettings indexScopedSettings = new IndexScopedSettings(Settings.EMPTY, definedSettings); + + mapperServices = new ArrayList<>(numIndices); + for (int i = 0; i < numIndices; i++) { + IndexMetadata meta = IndexMetadata.builder(randomIndexName()).settings(settings).build(); + IndexSettings indexSettings = new IndexSettings(meta, settings, indexScopedSettings); + MapperRegistry mapperRegistry = new IndicesModule(List.of(logsDBPlugin)).getMapperRegistry(); + SimilarityService similarityService = new SimilarityService(indexSettings, null, Map.of()); + BitsetFilterCache bitsetFilterCache = new BitsetFilterCache(indexSettings, BitsetFilterCache.Listener.NOOP); + MapperService mapperService = new MapperService( + () -> TransportVersion.current(), + indexSettings, + IndexAnalyzers.of(Map.of()), + XContentParserConfiguration.EMPTY.withRegistry(new NamedXContentRegistry(ClusterModule.getNamedXWriteables())) + .withDeprecationHandler(LoggingDeprecationHandler.INSTANCE), + similarityService, + mapperRegistry, + () -> { + throw new UnsupportedOperationException(); + }, + new ProvidedIdFieldMapper(() -> true), + new ScriptCompiler() { + @Override + public T compile(Script script, ScriptContext scriptContext) { + throw new UnsupportedOperationException(); + } + }, + bitsetFilterCache::getBitSetProducer, + MapperMetrics.NOOP + ); + + mapperServices.add(mapperService); + } + + compressedMapping = new CompressedXContent(MAPPING); + } + + @Benchmark + public void mappingParsingBenchmark() { + for (MapperService service : mapperServices) { + service.merge("_doc", compressedMapping, MapperService.MergeReason.MAPPING_UPDATE); + } + } +} From bcfa5ec8644414a7310b958480fc03a7772f2cd6 Mon Sep 17 00:00:00 2001 From: Jordan Powers Date: Thu, 20 Nov 2025 08:39:22 -0800 Subject: [PATCH 2/3] Use constant lists for default sort settings --- .../common/MappingParsingBenchmark.java | 4 +- .../elasticsearch/index/IndexSortConfig.java | 159 +++++++++++------- .../support/TimeSeriesIndexSearcher.java | 10 +- .../support/TimeSeriesIndexSearcherTests.java | 8 +- 4 files changed, 109 insertions(+), 72 deletions(-) diff --git a/benchmarks/src/main/java/org/elasticsearch/benchmark/indices/common/MappingParsingBenchmark.java b/benchmarks/src/main/java/org/elasticsearch/benchmark/indices/common/MappingParsingBenchmark.java index 13e8b7f861d13..cb9ff8773132b 100644 --- a/benchmarks/src/main/java/org/elasticsearch/benchmark/indices/common/MappingParsingBenchmark.java +++ b/benchmarks/src/main/java/org/elasticsearch/benchmark/indices/common/MappingParsingBenchmark.java @@ -33,6 +33,7 @@ import org.elasticsearch.script.ScriptContext; import org.elasticsearch.xcontent.NamedXContentRegistry; import org.elasticsearch.xcontent.XContentParserConfiguration; +import org.elasticsearch.xpack.logsdb.LogsDBPlugin; import org.openjdk.jmh.annotations.Benchmark; import org.openjdk.jmh.annotations.BenchmarkMode; import org.openjdk.jmh.annotations.Fork; @@ -45,11 +46,8 @@ import org.openjdk.jmh.annotations.State; import org.openjdk.jmh.annotations.Warmup; -import org.elasticsearch.xpack.logsdb.LogsDBPlugin; - import java.io.IOException; import java.util.ArrayList; -import java.util.Collections; import java.util.HashSet; import java.util.List; import java.util.Map; diff --git a/server/src/main/java/org/elasticsearch/index/IndexSortConfig.java b/server/src/main/java/org/elasticsearch/index/IndexSortConfig.java index 39475a1bf89f8..a3016b756bf44 100644 --- a/server/src/main/java/org/elasticsearch/index/IndexSortConfig.java +++ b/server/src/main/java/org/elasticsearch/index/IndexSortConfig.java @@ -27,7 +27,7 @@ import org.elasticsearch.search.sort.SortOrder; import java.util.ArrayList; -import java.util.Arrays; +import java.util.Collections; import java.util.EnumSet; import java.util.List; import java.util.Locale; @@ -107,31 +107,68 @@ public final class IndexSortConfig { ); public static class IndexSortConfigDefaults { - public static final FieldSortSpec[] TIME_SERIES_SORT, HOSTNAME_TIMESTAMP_BWC_SORT; + public record SortDefault(List fields, List order, List mode, List missing) { + public SortDefault { + assert fields.size() == order.size(); + assert fields.size() == mode.size(); + assert fields.size() == missing.size(); + } + } - private static final FieldSortSpec HOSTNAME_SPEC, MESSAGE_PATTERN_SPEC, TIMESTAMP_SPEC; + public static final SortDefault NO_SORT, TIME_SERIES_SORT, TIMESTAMP_SORT, HOSTNAME_TIMESTAMP_SORT, HOSTNAME_TIMESTAMP_BWC_SORT, + MESSAGE_PATTERN_TIMESTAMP_SORT, HOSTNAME_MESSAGE_PATTERN_TIMESTAMP_SORT; static { - TIMESTAMP_SPEC = new FieldSortSpec(DataStreamTimestampFieldMapper.DEFAULT_PATH); - TIMESTAMP_SPEC.order = SortOrder.DESC; - TIME_SERIES_SORT = new FieldSortSpec[] { new FieldSortSpec(TimeSeriesIdFieldMapper.NAME), TIMESTAMP_SPEC }; + NO_SORT = new SortDefault(Collections.emptyList(), Collections.emptyList(), Collections.emptyList(), Collections.emptyList()); - HOSTNAME_SPEC = new FieldSortSpec(IndexMode.HOST_NAME); - HOSTNAME_SPEC.order = SortOrder.ASC; - HOSTNAME_SPEC.missingValue = "_last"; - HOSTNAME_SPEC.mode = MultiValueMode.MIN; + TIME_SERIES_SORT = new SortDefault( + List.of(TimeSeriesIdFieldMapper.NAME, DataStreamTimestampFieldMapper.DEFAULT_PATH), + List.of("asc", "desc"), + List.of("min", "max"), + List.of("_last", "_last") + ); + + TIMESTAMP_SORT = new SortDefault( + List.of(DataStreamTimestampFieldMapper.DEFAULT_PATH), + List.of("desc"), + List.of("max"), + List.of("_last") + ); + + HOSTNAME_TIMESTAMP_SORT = new SortDefault( + List.of(IndexMode.HOST_NAME, DataStreamTimestampFieldMapper.DEFAULT_PATH), + List.of("asc", "desc"), + List.of("min", "max"), + List.of("_last", "_last") + ); + + MESSAGE_PATTERN_TIMESTAMP_SORT = new SortDefault( + List.of("message.template_id", DataStreamTimestampFieldMapper.DEFAULT_PATH), + List.of("asc", "desc"), + List.of("min", "max"), + List.of("_last", "_last") + ); - MESSAGE_PATTERN_SPEC = new FieldSortSpec("message.template_id"); + HOSTNAME_MESSAGE_PATTERN_TIMESTAMP_SORT = new SortDefault( + List.of(IndexMode.HOST_NAME, "message.template_id", DataStreamTimestampFieldMapper.DEFAULT_PATH), + List.of("asc", "asc", "desc"), + List.of("min", "min", "max"), + List.of("_last", "_last", "_last") + ); // Older indexes use ascending ordering for host name and timestamp. - HOSTNAME_TIMESTAMP_BWC_SORT = new FieldSortSpec[] { - new FieldSortSpec(IndexMode.HOST_NAME), - new FieldSortSpec(DataStreamTimestampFieldMapper.DEFAULT_PATH) }; + HOSTNAME_TIMESTAMP_BWC_SORT = new SortDefault( + List.of(IndexMode.HOST_NAME, DataStreamTimestampFieldMapper.DEFAULT_PATH), + List.of("asc", "asc"), + List.of("min", "min"), + List.of("_last", "_last") + ); + } - public static FieldSortSpec[] getDefaultSortSpecs(Settings settings) { + static SortDefault getSortDefault(Settings settings) { if (settings.isEmpty()) { - return new FieldSortSpec[0]; + return NO_SORT; } // Can't use IndexSettings.MODE.get(settings) here because the validation logic for IndexSettings.MODE uses the default value @@ -152,71 +189,73 @@ public static FieldSortSpec[] getDefaultSortSpecs(Settings settings) { IndexVersions.UPGRADE_TO_LUCENE_10_0_0 )) { - List sortSpecs = new ArrayList<>(3); - if (IndexSettings.LOGSDB_SORT_ON_HOST_NAME.get(settings)) { - sortSpecs.add(HOSTNAME_SPEC); + boolean sortOnHostName = IndexSettings.LOGSDB_SORT_ON_HOST_NAME.get(settings); + boolean sortOnMessageTemplate = IndexSettings.LOGSDB_SORT_ON_MESSAGE_TEMPLATE.get(settings); + if (sortOnHostName && sortOnMessageTemplate) { + return HOSTNAME_MESSAGE_PATTERN_TIMESTAMP_SORT; + } else if (sortOnHostName) { + return HOSTNAME_TIMESTAMP_SORT; + } else if (sortOnMessageTemplate) { + return MESSAGE_PATTERN_TIMESTAMP_SORT; + } else { + return TIMESTAMP_SORT; } - if (IndexSettings.LOGSDB_SORT_ON_MESSAGE_TEMPLATE.get(settings)) { - sortSpecs.add(MESSAGE_PATTERN_SPEC); - } - sortSpecs.add(TIMESTAMP_SPEC); - - return sortSpecs.toArray(FieldSortSpec[]::new); } else { return HOSTNAME_TIMESTAMP_BWC_SORT; } } - return new FieldSortSpec[0]; + return NO_SORT; } - public static FieldSortSpec[] getSortSpecs(Settings settings) { + public static List getDefaultSortFields(Settings settings) { + return getSortDefault(settings).fields(); + } + + public static List getDefaultSortOrder(Settings settings) { if (INDEX_SORT_FIELD_SETTING.exists(settings) == false) { - return IndexSortConfigDefaults.getDefaultSortSpecs(settings); + return getSortDefault(settings).order(); } - List fields = INDEX_SORT_FIELD_SETTING.get(settings); - FieldSortSpec[] sortSpecs = fields.stream().map(FieldSortSpec::new).toArray(FieldSortSpec[]::new); - - // Need to populate `order` because the default value of `mode` depends on it - if (INDEX_SORT_ORDER_SETTING.exists(settings)) { - List orders = INDEX_SORT_ORDER_SETTING.get(settings); - for (int i = 0; i < sortSpecs.length; i++) { - sortSpecs[i].order = orders.get(i); - } + List sortFields = INDEX_SORT_FIELD_SETTING.get(settings); + List order = new ArrayList<>(sortFields.size()); + for (int i = 0; i < sortFields.size(); ++i) { + order.add("asc"); } - - return sortSpecs; + return order; } - public static List getDefaultSortFields(Settings settings) { - return Arrays.stream(getDefaultSortSpecs(settings)).map(sortSpec -> sortSpec.field).toList(); - } + public static List getDefaultSortMode(Settings settings) { + if (INDEX_SORT_FIELD_SETTING.exists(settings) == false) { + return getSortDefault(settings).mode(); + } - public static List getDefaultSortOrder(Settings settings) { - return Arrays.stream(getSortSpecs(settings)) - .map(sortSpec -> sortSpec.order != null ? sortSpec.order : SortOrder.ASC) - .map(Enum::toString) - .toList(); - } + List sortFields = INDEX_SORT_FIELD_SETTING.get(settings); + List sortOrder = INDEX_SORT_ORDER_SETTING.exists(settings) ? INDEX_SORT_ORDER_SETTING.get(settings) : null; - public static List getDefaultSortMode(Settings settings) { - return Arrays.stream(getSortSpecs(settings)).map(sortSpec -> { - if (sortSpec.mode != null) { - return sortSpec.mode; - } else if (sortSpec.order == SortOrder.DESC) { - return MultiValueMode.MAX; + List mode = new ArrayList<>(sortFields.size()); + for (int i = 0; i < sortFields.size(); ++i) { + if (sortOrder != null && sortOrder.get(i) == SortOrder.DESC) { + mode.add("max"); } else { - return MultiValueMode.MIN; + mode.add("min"); } - }).map(order -> order.toString().toLowerCase(Locale.ROOT)).toList(); + } + return mode; } public static List getDefaultSortMissing(Settings settings) { - // _last is the default per IndexFieldData.XFieldComparatorSource.Nested#sortMissingLast - return Arrays.stream(getSortSpecs(settings)) - .map(sortSpec -> sortSpec.missingValue != null ? sortSpec.missingValue : "_last") - .toList(); + if (INDEX_SORT_FIELD_SETTING.exists(settings) == false) { + return getSortDefault(settings).missing(); + } + + List sortFields = INDEX_SORT_FIELD_SETTING.get(settings); + List missing = new ArrayList<>(sortFields.size()); + for (int i = 0; i < sortFields.size(); ++i) { + // _last is the default per IndexFieldData.XFieldComparatorSource.Nested#sortMissingLast + missing.add("_last"); + } + return missing; } } diff --git a/server/src/main/java/org/elasticsearch/search/aggregations/support/TimeSeriesIndexSearcher.java b/server/src/main/java/org/elasticsearch/search/aggregations/support/TimeSeriesIndexSearcher.java index 02947a0ead663..f6c6432fc8e7b 100644 --- a/server/src/main/java/org/elasticsearch/search/aggregations/support/TimeSeriesIndexSearcher.java +++ b/server/src/main/java/org/elasticsearch/search/aggregations/support/TimeSeriesIndexSearcher.java @@ -73,11 +73,11 @@ public TimeSeriesIndexSearcher(IndexSearcher searcher, List cancellati this.cancellations = cancellations; cancellations.forEach(this.searcher::addQueryCancellation); - assert TIME_SERIES_SORT.length == 2; - assert TIME_SERIES_SORT[0].getField().equals(TimeSeriesIdFieldMapper.NAME); - assert TIME_SERIES_SORT[1].getField().equals(DataStreamTimestampFieldMapper.DEFAULT_PATH); - this.tsidReverse = TIME_SERIES_SORT[0].getOrder() == SortOrder.DESC; - this.timestampReverse = TIME_SERIES_SORT[1].getOrder() == SortOrder.DESC; + assert TIME_SERIES_SORT.fields().size() == 2; + assert TIME_SERIES_SORT.fields().get(0).equals(TimeSeriesIdFieldMapper.NAME); + assert TIME_SERIES_SORT.fields().get(1).equals(DataStreamTimestampFieldMapper.DEFAULT_PATH); + this.tsidReverse = TIME_SERIES_SORT.order().get(0).equals(SortOrder.DESC.toString()); + this.timestampReverse = TIME_SERIES_SORT.order().get(1).equals(SortOrder.DESC.toString()); } public void setMinimumScore(Float minimumScore) { diff --git a/server/src/test/java/org/elasticsearch/search/aggregations/support/TimeSeriesIndexSearcherTests.java b/server/src/test/java/org/elasticsearch/search/aggregations/support/TimeSeriesIndexSearcherTests.java index d7cf0b76681a6..8ca4b41b67bb7 100644 --- a/server/src/test/java/org/elasticsearch/search/aggregations/support/TimeSeriesIndexSearcherTests.java +++ b/server/src/test/java/org/elasticsearch/search/aggregations/support/TimeSeriesIndexSearcherTests.java @@ -214,8 +214,8 @@ public void testCollectFromMiddle() throws IOException { private RandomIndexWriter getIndexWriter(Directory dir) throws IOException { IndexWriterConfig iwc = newIndexWriterConfig(); - boolean tsidReverse = TIME_SERIES_SORT[0].getOrder() == SortOrder.DESC; - boolean timestampReverse = TIME_SERIES_SORT[1].getOrder() == SortOrder.DESC; + boolean tsidReverse = TIME_SERIES_SORT.order().get(0).equals(SortOrder.DESC.toString()); + boolean timestampReverse = TIME_SERIES_SORT.order().get(1).equals(SortOrder.DESC.toString()); Sort sort = new Sort( new SortField(TimeSeriesIdFieldMapper.NAME, SortField.Type.STRING, tsidReverse), new SortField(DataStream.TIMESTAMP_FIELD_NAME, SortField.Type.LONG, timestampReverse) @@ -227,8 +227,8 @@ private RandomIndexWriter getIndexWriter(Directory dir) throws IOException { private BucketCollector getBucketCollector(long totalCount) { return new BucketCollector() { - final boolean tsidReverse = TIME_SERIES_SORT[0].getOrder() == SortOrder.DESC; - final boolean timestampReverse = TIME_SERIES_SORT[1].getOrder() == SortOrder.DESC; + final boolean tsidReverse = TIME_SERIES_SORT.order().get(0).equals(SortOrder.DESC.toString()); + final boolean timestampReverse = TIME_SERIES_SORT.order().get(1).equals(SortOrder.DESC.toString()); BytesRef currentTSID = null; int currentTSIDord = -1; long currentTimestamp = 0; From 397cd92f6358899cd243a001fc78f93d34c2e259 Mon Sep 17 00:00:00 2001 From: Jordan Powers Date: Tue, 25 Nov 2025 21:40:22 -0800 Subject: [PATCH 3/3] Further optimize --- .../elasticsearch/index/IndexSortConfig.java | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/server/src/main/java/org/elasticsearch/index/IndexSortConfig.java b/server/src/main/java/org/elasticsearch/index/IndexSortConfig.java index a3016b756bf44..731d72fe2f63a 100644 --- a/server/src/main/java/org/elasticsearch/index/IndexSortConfig.java +++ b/server/src/main/java/org/elasticsearch/index/IndexSortConfig.java @@ -189,8 +189,8 @@ static SortDefault getSortDefault(Settings settings) { IndexVersions.UPGRADE_TO_LUCENE_10_0_0 )) { - boolean sortOnHostName = IndexSettings.LOGSDB_SORT_ON_HOST_NAME.get(settings); - boolean sortOnMessageTemplate = IndexSettings.LOGSDB_SORT_ON_MESSAGE_TEMPLATE.get(settings); + boolean sortOnHostName = settings.getAsBoolean(IndexSettings.LOGSDB_SORT_ON_HOST_NAME.getKey(), false); + boolean sortOnMessageTemplate = settings.getAsBoolean(IndexSettings.LOGSDB_SORT_ON_MESSAGE_TEMPLATE.getKey(), false); if (sortOnHostName && sortOnMessageTemplate) { return HOSTNAME_MESSAGE_PATTERN_TIMESTAMP_SORT; } else if (sortOnHostName) { @@ -213,11 +213,11 @@ public static List getDefaultSortFields(Settings settings) { } public static List getDefaultSortOrder(Settings settings) { - if (INDEX_SORT_FIELD_SETTING.exists(settings) == false) { + if (settings.hasValue(INDEX_SORT_FIELD_SETTING.getKey()) == false) { return getSortDefault(settings).order(); } - List sortFields = INDEX_SORT_FIELD_SETTING.get(settings); + List sortFields = settings.getAsList(INDEX_SORT_FIELD_SETTING.getKey()); List order = new ArrayList<>(sortFields.size()); for (int i = 0; i < sortFields.size(); ++i) { order.add("asc"); @@ -226,16 +226,16 @@ public static List getDefaultSortOrder(Settings settings) { } public static List getDefaultSortMode(Settings settings) { - if (INDEX_SORT_FIELD_SETTING.exists(settings) == false) { + if (settings.hasValue(INDEX_SORT_FIELD_SETTING.getKey()) == false) { return getSortDefault(settings).mode(); } - List sortFields = INDEX_SORT_FIELD_SETTING.get(settings); - List sortOrder = INDEX_SORT_ORDER_SETTING.exists(settings) ? INDEX_SORT_ORDER_SETTING.get(settings) : null; + List sortFields = settings.getAsList(INDEX_SORT_FIELD_SETTING.getKey()); + List sortOrder = settings.getAsList(INDEX_SORT_ORDER_SETTING.getKey(), null); List mode = new ArrayList<>(sortFields.size()); for (int i = 0; i < sortFields.size(); ++i) { - if (sortOrder != null && sortOrder.get(i) == SortOrder.DESC) { + if (sortOrder != null && sortOrder.get(i).equals(SortOrder.DESC.toString())) { mode.add("max"); } else { mode.add("min"); @@ -245,11 +245,11 @@ public static List getDefaultSortMode(Settings settings) { } public static List getDefaultSortMissing(Settings settings) { - if (INDEX_SORT_FIELD_SETTING.exists(settings) == false) { + if (settings.hasValue(INDEX_SORT_FIELD_SETTING.getKey()) == false) { return getSortDefault(settings).missing(); } - List sortFields = INDEX_SORT_FIELD_SETTING.get(settings); + List sortFields = settings.getAsList(INDEX_SORT_FIELD_SETTING.getKey()); List missing = new ArrayList<>(sortFields.size()); for (int i = 0; i < sortFields.size(); ++i) { // _last is the default per IndexFieldData.XFieldComparatorSource.Nested#sortMissingLast