From 4157ea0b68782de4d6023dce212c783c5471a611 Mon Sep 17 00:00:00 2001 From: Craig Perkins Date: Wed, 5 Feb 2025 22:14:23 -0500 Subject: [PATCH 1/7] WIP on adding Searchable to SystemIndexDescriptor Signed-off-by: Craig Perkins --- .../metadata/IndexNameExpressionResolver.java | 41 ++++++++++++++----- .../indices/SystemIndexDescriptor.java | 35 +++++++++++++++- .../indices/SystemIndexRegistry.java | 6 +++ .../indices/SystemIndicesTests.java | 12 ++++++ 4 files changed, 82 insertions(+), 12 deletions(-) diff --git a/server/src/main/java/org/opensearch/cluster/metadata/IndexNameExpressionResolver.java b/server/src/main/java/org/opensearch/cluster/metadata/IndexNameExpressionResolver.java index 24ff83d638d4b..7ac15f23a820e 100644 --- a/server/src/main/java/org/opensearch/cluster/metadata/IndexNameExpressionResolver.java +++ b/server/src/main/java/org/opensearch/cluster/metadata/IndexNameExpressionResolver.java @@ -53,6 +53,8 @@ import org.opensearch.index.IndexNotFoundException; import org.opensearch.indices.IndexClosedException; import org.opensearch.indices.InvalidIndexNameException; +import org.opensearch.indices.SystemIndexDescriptor; +import org.opensearch.indices.SystemIndexRegistry; import java.time.Instant; import java.time.ZoneId; @@ -223,7 +225,8 @@ public Index[] concreteIndices(ClusterState state, IndicesRequest request, long false, request.includeDataStreams(), false, - isSystemIndexAccessAllowed() + isSystemIndexAccessAllowed(), + false ); return concreteIndices(context, request.indices()); } @@ -358,21 +361,28 @@ Index[] concreteIndices(Context context, String... indexExpressions) { private void checkSystemIndexAccess(Context context, Metadata metadata, Set concreteIndices, String[] originalPatterns) { if (context.isSystemIndexAccessAllowed() == false) { - final List resolvedSystemIndices = concreteIndices.stream() + final Set resolvedSystemIndices = concreteIndices.stream() .map(metadata::index) .filter(IndexMetadata::isSystem) .map(i -> i.getIndex().getName()) .sorted() // reliable order for testing - .collect(Collectors.toList()); + .collect(Collectors.toSet()); if (resolvedSystemIndices.isEmpty() == false) { - resolvedSystemIndices.forEach( - systemIndexName -> deprecationLogger.deprecate( + for (String systemIndexName : resolvedSystemIndices) { + SystemIndexDescriptor descriptor = SystemIndexRegistry.matchesSystemIndexDescriptor(resolvedSystemIndices) + .stream() + .findFirst() + .orElse(null); + if (descriptor != null && descriptor.isSearchable() && context.isSearchRequest()) { + continue; + } + deprecationLogger.deprecate( "open_system_index_access_" + systemIndexName, "this request accesses system indices: [{}], but in a future major version, direct access to system " + "indices will be prevented by default", systemIndexName - ) - ); + ); + } } } } @@ -788,6 +798,7 @@ public static class Context { private final boolean includeDataStreams; private final boolean preserveDataStreams; private final boolean isSystemIndexAccessAllowed; + private final boolean isSearchRequest; Context(ClusterState state, IndicesOptions options, boolean isSystemIndexAccessAllowed) { this(state, options, System.currentTimeMillis(), isSystemIndexAccessAllowed); @@ -809,7 +820,8 @@ public static class Context { resolveToWriteIndex, includeDataStreams, false, - isSystemIndexAccessAllowed + isSystemIndexAccessAllowed, + false ); } @@ -830,12 +842,13 @@ public static class Context { resolveToWriteIndex, includeDataStreams, preserveDataStreams, - isSystemIndexAccessAllowed + isSystemIndexAccessAllowed, + false ); } Context(ClusterState state, IndicesOptions options, long startTime, boolean isSystemIndexAccessAllowed) { - this(state, options, startTime, false, false, false, false, isSystemIndexAccessAllowed); + this(state, options, startTime, false, false, false, false, isSystemIndexAccessAllowed, false); } protected Context( @@ -846,7 +859,8 @@ protected Context( boolean resolveToWriteIndex, boolean includeDataStreams, boolean preserveDataStreams, - boolean isSystemIndexAccessAllowed + boolean isSystemIndexAccessAllowed, + boolean isSearchRequest ) { this.state = state; this.options = options; @@ -856,6 +870,7 @@ protected Context( this.includeDataStreams = includeDataStreams; this.preserveDataStreams = preserveDataStreams; this.isSystemIndexAccessAllowed = isSystemIndexAccessAllowed; + this.isSearchRequest = isSearchRequest; } public ClusterState getState() { @@ -895,6 +910,10 @@ public boolean isPreserveDataStreams() { return preserveDataStreams; } + public boolean isSearchRequest() { + return isSearchRequest; + } + /** * Used to determine if it is allowed to access system indices in this context (e.g. for this request). */ diff --git a/server/src/main/java/org/opensearch/indices/SystemIndexDescriptor.java b/server/src/main/java/org/opensearch/indices/SystemIndexDescriptor.java index c886b6c0c0607..b17263ebe04a2 100644 --- a/server/src/main/java/org/opensearch/indices/SystemIndexDescriptor.java +++ b/server/src/main/java/org/opensearch/indices/SystemIndexDescriptor.java @@ -50,6 +50,7 @@ public class SystemIndexDescriptor { private final String indexPattern; private final String description; private final CharacterRunAutomaton indexPatternAutomaton; + private boolean searchable; /** * @@ -104,9 +105,41 @@ public String getDescription() { return description; } + /** + * Set whether this system index is searchable. Defaults to false. + * @param searchable Whether this system index is searchable. + */ + public void setSearchable(boolean searchable) { + this.searchable = searchable; + } + + /** + * @return A boolean corresponding to whether this system index is searchable. + */ + public boolean isSearchable() { + return searchable; + } + @Override public String toString() { - return "SystemIndexDescriptor[pattern=[" + indexPattern + "], description=[" + description + "]]"; + return "SystemIndexDescriptor[pattern=[" + indexPattern + "], description=[" + description + "], searchable=[" + searchable + "]]"; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (!(obj instanceof SystemIndexDescriptor)) { + return false; + } + SystemIndexDescriptor other = (SystemIndexDescriptor) obj; + return indexPattern.equals(other.indexPattern); + } + + @Override + public int hashCode() { + return Objects.hash(indexPattern); } // TODO: Index settings and mapping diff --git a/server/src/main/java/org/opensearch/indices/SystemIndexRegistry.java b/server/src/main/java/org/opensearch/indices/SystemIndexRegistry.java index ab2cbd4ef1a73..7b36e196c3cf7 100644 --- a/server/src/main/java/org/opensearch/indices/SystemIndexRegistry.java +++ b/server/src/main/java/org/opensearch/indices/SystemIndexRegistry.java @@ -59,6 +59,12 @@ public static Set matchesSystemIndexPattern(Set indexExpressions return indexExpressions.stream().filter(pattern -> Regex.simpleMatch(SYSTEM_INDEX_PATTERNS, pattern)).collect(Collectors.toSet()); } + public static Set matchesSystemIndexDescriptor(Set indexExpressions) { + return getAllDescriptors().stream() + .filter(descriptor -> indexExpressions.stream().anyMatch(pattern -> Regex.simpleMatch(descriptor.getIndexPattern(), pattern))) + .collect(Collectors.toSet()); + } + public static Set matchesPluginSystemIndexPattern(String pluginClassName, Set indexExpressions) { if (!SYSTEM_INDEX_DESCRIPTORS_MAP.containsKey(pluginClassName)) { return Collections.emptySet(); diff --git a/server/src/test/java/org/opensearch/indices/SystemIndicesTests.java b/server/src/test/java/org/opensearch/indices/SystemIndicesTests.java index ca9370645dec3..3a84107c726cd 100644 --- a/server/src/test/java/org/opensearch/indices/SystemIndicesTests.java +++ b/server/src/test/java/org/opensearch/indices/SystemIndicesTests.java @@ -46,11 +46,13 @@ import java.util.Map; import java.util.Set; import java.util.stream.Collectors; +import java.util.stream.Stream; import static java.util.Collections.emptyMap; import static java.util.Collections.singletonList; import static java.util.Collections.singletonMap; import static org.opensearch.tasks.TaskResultsService.TASK_INDEX; +import static org.hamcrest.Matchers.containsInAnyOrder; import static org.hamcrest.Matchers.containsString; import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.not; @@ -189,6 +191,16 @@ public void testSystemIndexMatching() { equalTo(Set.of(".system-index1", ".system-index-pattern1")) ); assertThat(SystemIndexRegistry.matchesSystemIndexPattern(Set.of(".not-system")), equalTo(Collections.emptySet())); + + assertThat( + SystemIndexRegistry.matchesSystemIndexDescriptor(Set.of(".system-index1", ".system-index2")), + containsInAnyOrder( + Stream.concat( + plugin1.getSystemIndexDescriptors(Settings.EMPTY).stream(), + plugin2.getSystemIndexDescriptors(Settings.EMPTY).stream() + ).toArray() + ) + ); } public void testRegisteredSystemIndexGetAllDescriptors() { From 7bbfd04ba67354adef8694a417297ead6aed6b2c Mon Sep 17 00:00:00 2001 From: Craig Perkins Date: Fri, 7 Feb 2025 09:52:16 -0500 Subject: [PATCH 2/7] Switch to readable Signed-off-by: Craig Perkins --- .../metadata/IndexNameExpressionResolver.java | 14 +++++++------- .../indices/SystemIndexDescriptor.java | 19 ++++++++++--------- 2 files changed, 17 insertions(+), 16 deletions(-) diff --git a/server/src/main/java/org/opensearch/cluster/metadata/IndexNameExpressionResolver.java b/server/src/main/java/org/opensearch/cluster/metadata/IndexNameExpressionResolver.java index 7ac15f23a820e..b682d0743fa12 100644 --- a/server/src/main/java/org/opensearch/cluster/metadata/IndexNameExpressionResolver.java +++ b/server/src/main/java/org/opensearch/cluster/metadata/IndexNameExpressionResolver.java @@ -226,7 +226,7 @@ public Index[] concreteIndices(ClusterState state, IndicesRequest request, long request.includeDataStreams(), false, isSystemIndexAccessAllowed(), - false + true ); return concreteIndices(context, request.indices()); } @@ -373,7 +373,7 @@ private void checkSystemIndexAccess(Context context, Metadata metadata, Set Date: Fri, 7 Feb 2025 10:59:42 -0500 Subject: [PATCH 3/7] Default to true except in the case of concreteWriteIndices Signed-off-by: Craig Perkins --- .../metadata/IndexNameExpressionResolver.java | 20 ++++++++++++++----- 1 file changed, 15 insertions(+), 5 deletions(-) diff --git a/server/src/main/java/org/opensearch/cluster/metadata/IndexNameExpressionResolver.java b/server/src/main/java/org/opensearch/cluster/metadata/IndexNameExpressionResolver.java index b682d0743fa12..b10b5711ce4ff 100644 --- a/server/src/main/java/org/opensearch/cluster/metadata/IndexNameExpressionResolver.java +++ b/server/src/main/java/org/opensearch/cluster/metadata/IndexNameExpressionResolver.java @@ -491,7 +491,17 @@ public Index concreteWriteIndex( options.ignoreThrottled() ); - Context context = new Context(state, combinedOptions, false, true, includeDataStreams, isSystemIndexAccessAllowed()); + Context context = new Context( + state, + combinedOptions, + System.currentTimeMillis(), + false, + true, + includeDataStreams, + false, + isSystemIndexAccessAllowed(), + false + ); Index[] indices = concreteIndices(context, index); if (allowNoIndices && indices.length == 0) { return null; @@ -821,7 +831,7 @@ public static class Context { includeDataStreams, false, isSystemIndexAccessAllowed, - false + true ); } @@ -843,15 +853,15 @@ public static class Context { includeDataStreams, preserveDataStreams, isSystemIndexAccessAllowed, - false + true ); } Context(ClusterState state, IndicesOptions options, long startTime, boolean isSystemIndexAccessAllowed) { - this(state, options, startTime, false, false, false, false, isSystemIndexAccessAllowed, false); + this(state, options, startTime, false, false, false, false, isSystemIndexAccessAllowed, true); } - protected Context( + Context( ClusterState state, IndicesOptions options, long startTime, From 9a54a4e3fac436577c5aeb6889edaa1e4f5fd0e3 Mon Sep 17 00:00:00 2001 From: Craig Perkins Date: Fri, 7 Feb 2025 12:40:52 -0500 Subject: [PATCH 4/7] Add test for vanilla search Signed-off-by: Craig Perkins --- .../resthandler/ExampleRestHandlerPlugin.java | 18 ++++++++-- .../resthandler/30_readable_system_index.yml | 33 ++++++++++++++++++ .../40_nonreadable_system_index.yml | 34 +++++++++++++++++++ .../indices/SystemIndexDescriptor.java | 22 ++++++------ 4 files changed, 95 insertions(+), 12 deletions(-) create mode 100644 plugins/examples/rest-handler/src/yamlRestTest/resources/rest-api-spec/test/resthandler/30_readable_system_index.yml create mode 100644 plugins/examples/rest-handler/src/yamlRestTest/resources/rest-api-spec/test/resthandler/40_nonreadable_system_index.yml diff --git a/plugins/examples/rest-handler/src/main/java/org/opensearch/example/resthandler/ExampleRestHandlerPlugin.java b/plugins/examples/rest-handler/src/main/java/org/opensearch/example/resthandler/ExampleRestHandlerPlugin.java index ec7f4c8fdd7ae..c042dd57cd438 100644 --- a/plugins/examples/rest-handler/src/main/java/org/opensearch/example/resthandler/ExampleRestHandlerPlugin.java +++ b/plugins/examples/rest-handler/src/main/java/org/opensearch/example/resthandler/ExampleRestHandlerPlugin.java @@ -38,11 +38,15 @@ import org.opensearch.common.settings.IndexScopedSettings; import org.opensearch.common.settings.Settings; import org.opensearch.common.settings.SettingsFilter; +import org.opensearch.indices.SystemIndexDescriptor; import org.opensearch.plugins.ActionPlugin; +import org.opensearch.plugins.ClusterPlugin; import org.opensearch.plugins.Plugin; +import org.opensearch.plugins.SystemIndexPlugin; import org.opensearch.rest.RestController; import org.opensearch.rest.RestHandler; +import java.util.Collection; import java.util.List; import java.util.function.Supplier; @@ -51,7 +55,10 @@ /** * A plugin demonstrating the implementation of a new Rest Handler. */ -public class ExampleRestHandlerPlugin extends Plugin implements ActionPlugin { +public class ExampleRestHandlerPlugin extends Plugin implements ActionPlugin, SystemIndexPlugin, ClusterPlugin { + + public static final String READABLE_SYSTEM_INDEX_NAME = ".readable-system-index"; + public static final String NONREADABLE_SYSTEM_INDEX_NAME = ".nonreadable-system-index"; /** * Instantiate this plugin. @@ -68,7 +75,14 @@ public List getRestHandlers( final IndexNameExpressionResolver indexNameExpressionResolver, final Supplier nodesInCluster ) { - return singletonList(new ExampleCatAction()); } + + @Override + public Collection getSystemIndexDescriptors(Settings settings) { + return List.of( + new SystemIndexDescriptor(READABLE_SYSTEM_INDEX_NAME, "Readable system index for tests", true), + new SystemIndexDescriptor(NONREADABLE_SYSTEM_INDEX_NAME, "Non-Readable system index for tests") + ); + } } diff --git a/plugins/examples/rest-handler/src/yamlRestTest/resources/rest-api-spec/test/resthandler/30_readable_system_index.yml b/plugins/examples/rest-handler/src/yamlRestTest/resources/rest-api-spec/test/resthandler/30_readable_system_index.yml new file mode 100644 index 0000000000000..3d43c466b2350 --- /dev/null +++ b/plugins/examples/rest-handler/src/yamlRestTest/resources/rest-api-spec/test/resthandler/30_readable_system_index.yml @@ -0,0 +1,33 @@ +--- +setup: + - skip: + features: allowed_warnings + - do: + indices.create: + index: .readable-system-index + + - do: + allowed_warnings: + - "this request accesses system indices: [.readable-system-index], but in a future major version, direct access to system indices will be prevented by default" + index: + index: .readable-system-index + id: 1 + refresh: true + body: + query: + match_all: { } + +--- +"Test that .readable-system-index does not output deprecation log on search": + - skip: + features: [warnings, headers] + - do: + warnings: [] + headers: { "X-Opaque-Id": "search-request" } + search: + rest_total_hits_as_int: true + index: .readable-system-index + body: + query: + match_all: { } + - match: { hits.total: 1 } diff --git a/plugins/examples/rest-handler/src/yamlRestTest/resources/rest-api-spec/test/resthandler/40_nonreadable_system_index.yml b/plugins/examples/rest-handler/src/yamlRestTest/resources/rest-api-spec/test/resthandler/40_nonreadable_system_index.yml new file mode 100644 index 0000000000000..84e86c78bf68c --- /dev/null +++ b/plugins/examples/rest-handler/src/yamlRestTest/resources/rest-api-spec/test/resthandler/40_nonreadable_system_index.yml @@ -0,0 +1,34 @@ +--- +setup: + - skip: + features: allowed_warnings + - do: + indices.create: + index: .nonreadable-system-index + + - do: + allowed_warnings: + - "this request accesses system indices: [.nonreadable-system-index], but in a future major version, direct access to system indices will be prevented by default" + index: + index: .nonreadable-system-index + id: 1 + refresh: true + body: + query: + match_all: { } + +--- +"Test that .nonreadable-system-index does output deprecation log on search": + - skip: + features: [warnings, headers] + - do: + headers: { "X-Opaque-Id": "search-request" } + warnings: + - "this request accesses system indices: [.nonreadable-system-index], but in a future major version, direct access to system indices will be prevented by default" + search: + rest_total_hits_as_int: true + index: .nonreadable-system-index + body: + query: + match_all: { } + - match: { hits.total: 1 } diff --git a/server/src/main/java/org/opensearch/indices/SystemIndexDescriptor.java b/server/src/main/java/org/opensearch/indices/SystemIndexDescriptor.java index 49c519f5b7d11..936b9f3ea0bc5 100644 --- a/server/src/main/java/org/opensearch/indices/SystemIndexDescriptor.java +++ b/server/src/main/java/org/opensearch/indices/SystemIndexDescriptor.java @@ -56,8 +56,9 @@ public class SystemIndexDescriptor { * * @param indexPattern The pattern of index names that this descriptor will be used for. Must start with a '.' character. * @param description The name of the plugin responsible for this system index. + * @param readable Whether this system index is readable. A readable index is one where search and get actions are permitted. */ - public SystemIndexDescriptor(String indexPattern, String description) { + public SystemIndexDescriptor(String indexPattern, String description, boolean readable) { Objects.requireNonNull(indexPattern, "system index pattern must not be null"); if (indexPattern.length() < 2) { throw new IllegalArgumentException( @@ -80,6 +81,16 @@ public SystemIndexDescriptor(String indexPattern, String description) { Automaton a = Operations.determinize(Regex.simpleMatchToAutomaton(indexPattern), Operations.DEFAULT_DETERMINIZE_WORK_LIMIT); this.indexPatternAutomaton = new CharacterRunAutomaton(a); this.description = description; + this.readable = readable; + } + + /** + * + * @param indexPattern The pattern of index names that this descriptor will be used for. Must start with a '.' character. + * @param description The name of the plugin responsible for this system index. + */ + public SystemIndexDescriptor(String indexPattern, String description) { + this(indexPattern, description, false); } /** @@ -105,15 +116,6 @@ public String getDescription() { return description; } - /** - * Set whether this system index is readable. Defaults to false. - * @param readable Whether this system index is readable. A readable index is one where search and get - * actions are permitted. - */ - public void setReadable(boolean readable) { - this.readable = readable; - } - /** * @return A boolean corresponding to whether this system index is readable. */ From 40f2afca39106eae74f6a87218f1dd5c922fc486 Mon Sep 17 00:00:00 2001 From: Craig Perkins Date: Fri, 7 Feb 2025 12:57:22 -0500 Subject: [PATCH 5/7] Add tests for GET Request Signed-off-by: Craig Perkins --- .../test/resthandler/30_readable_system_index.yml | 12 +++++++++--- .../resthandler/40_nonreadable_system_index.yml | 13 ++++++++++--- 2 files changed, 19 insertions(+), 6 deletions(-) diff --git a/plugins/examples/rest-handler/src/yamlRestTest/resources/rest-api-spec/test/resthandler/30_readable_system_index.yml b/plugins/examples/rest-handler/src/yamlRestTest/resources/rest-api-spec/test/resthandler/30_readable_system_index.yml index 3d43c466b2350..c8ae84a303ac6 100644 --- a/plugins/examples/rest-handler/src/yamlRestTest/resources/rest-api-spec/test/resthandler/30_readable_system_index.yml +++ b/plugins/examples/rest-handler/src/yamlRestTest/resources/rest-api-spec/test/resthandler/30_readable_system_index.yml @@ -13,9 +13,7 @@ setup: index: .readable-system-index id: 1 refresh: true - body: - query: - match_all: { } + body: { "test": 1 } --- "Test that .readable-system-index does not output deprecation log on search": @@ -31,3 +29,11 @@ setup: query: match_all: { } - match: { hits.total: 1 } + + - do: + warnings: [ ] + headers: { "X-Opaque-Id": "get-request" } + get: + index: .readable-system-index + id: 1 + - match: { _source.test: 1 } diff --git a/plugins/examples/rest-handler/src/yamlRestTest/resources/rest-api-spec/test/resthandler/40_nonreadable_system_index.yml b/plugins/examples/rest-handler/src/yamlRestTest/resources/rest-api-spec/test/resthandler/40_nonreadable_system_index.yml index 84e86c78bf68c..8c1ffa9a50321 100644 --- a/plugins/examples/rest-handler/src/yamlRestTest/resources/rest-api-spec/test/resthandler/40_nonreadable_system_index.yml +++ b/plugins/examples/rest-handler/src/yamlRestTest/resources/rest-api-spec/test/resthandler/40_nonreadable_system_index.yml @@ -13,9 +13,7 @@ setup: index: .nonreadable-system-index id: 1 refresh: true - body: - query: - match_all: { } + body: { "test": 1 } --- "Test that .nonreadable-system-index does output deprecation log on search": @@ -32,3 +30,12 @@ setup: query: match_all: { } - match: { hits.total: 1 } + + - do: + warnings: + - "this request accesses system indices: [.nonreadable-system-index], but in a future major version, direct access to system indices will be prevented by default" + headers: { "X-Opaque-Id": "get-request" } + get: + index: .nonreadable-system-index + id: 1 + - match: { _source.test: 1 } From 2ce642f6bf42c33f189a247df99a28e8aebce267 Mon Sep 17 00:00:00 2001 From: Craig Perkins Date: Fri, 7 Feb 2025 15:58:47 -0500 Subject: [PATCH 6/7] Add javadoc Signed-off-by: Craig Perkins --- .../example/resthandler/ExampleRestHandlerPlugin.java | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/plugins/examples/rest-handler/src/main/java/org/opensearch/example/resthandler/ExampleRestHandlerPlugin.java b/plugins/examples/rest-handler/src/main/java/org/opensearch/example/resthandler/ExampleRestHandlerPlugin.java index c042dd57cd438..9c280eff4613a 100644 --- a/plugins/examples/rest-handler/src/main/java/org/opensearch/example/resthandler/ExampleRestHandlerPlugin.java +++ b/plugins/examples/rest-handler/src/main/java/org/opensearch/example/resthandler/ExampleRestHandlerPlugin.java @@ -57,7 +57,14 @@ */ public class ExampleRestHandlerPlugin extends Plugin implements ActionPlugin, SystemIndexPlugin, ClusterPlugin { + /** + * The name of the readable system index. + */ public static final String READABLE_SYSTEM_INDEX_NAME = ".readable-system-index"; + + /** + * The name of the non-readable system index. + */ public static final String NONREADABLE_SYSTEM_INDEX_NAME = ".nonreadable-system-index"; /** From 929243dd34a103859892f2452401c3624d23a300 Mon Sep 17 00:00:00 2001 From: Craig Perkins Date: Fri, 7 Feb 2025 16:28:33 -0500 Subject: [PATCH 7/7] Add to CHANGELOG Signed-off-by: Craig Perkins --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index c4fccc9d54eb7..f264a46fe0a16 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -41,6 +41,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), - Propagate the sourceIncludes and excludes fields from fetchSourceContext to FieldsVisitor. ([#17080](https://github.com/opensearch-project/OpenSearch/pull/17080)) - [Star Tree] [Search] Resolving Date histogram with metric aggregation using star-tree ([#16674](https://github.com/opensearch-project/OpenSearch/pull/16674)) - [Star Tree] [Search] Extensible design to support different query and field types ([#17137](https://github.com/opensearch-project/OpenSearch/pull/17137)) +- Add a flag to set whether a system index is readable on SystemIndexDescriptor ([#17296](https://github.com/opensearch-project/OpenSearch/pull/17296)) ### Dependencies - Bump `com.google.cloud:google-cloud-core-http` from 2.23.0 to 2.47.0 ([#16504](https://github.com/opensearch-project/OpenSearch/pull/16504))