Preserve grok pattern ordering and add sort option

libs/grok/src/main/java/org/elasticsearch/grok/Grok.java

@@ -37,6 +37,7 @@
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Iterator;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
@@ -288,7 +289,7 @@ private static Map<String, String> loadBuiltinPatterns() throws IOException {
             "java", "junos", "linux-syslog", "maven", "mcollective-patterns", "mongodb", "nagios",
             "postgresql", "rails", "redis", "ruby", "squid"
         };
-        Map<String, String> builtinPatterns = new HashMap<>();
+        Map<String, String> builtinPatterns = new LinkedHashMap<>();
         for (String pattern : PATTERN_NAMES) {
             try(InputStream is = Grok.class.getResourceAsStream("/patterns/" + pattern)) {
                 loadPatterns(builtinPatterns, is);

modules/ingest-common/src/main/java/org/elasticsearch/ingest/common/GrokProcessorGetAction.java

@@ -40,6 +40,7 @@
 import java.io.IOException;
 import java.util.List;
 import java.util.Map;
+import java.util.TreeMap;
 
 import static org.elasticsearch.ingest.common.IngestCommonPlugin.GROK_PATTERNS;
 import static org.elasticsearch.rest.RestRequest.Method.GET;
@@ -55,16 +56,31 @@ private GrokProcessorGetAction() {
 
     public static class Request extends ActionRequest {
 
-        public Request() {}
+        private final boolean sorted;
+
+        public Request(boolean sorted) {
+            this.sorted = sorted;
+        }
 
         Request(StreamInput in) throws IOException {
             super(in);
+            this.sorted = in.readBoolean();
         }
 
         @Override
         public ActionRequestValidationException validate() {
             return null;
         }
+
+        @Override
+        public void writeTo(StreamOutput out) throws IOException {
+            super.writeTo(out);
+            out.writeBoolean(sorted);
+        }
+
+        public boolean sorted() {
+            return sorted;
+        }
     }
 
     public static class Response extends ActionResponse implements ToXContentObject {
@@ -108,11 +124,15 @@ public TransportAction(TransportService transportService, ActionFilters actionFi
         @Override
         protected void doExecute(Task task, Request request, ActionListener<Response> listener) {
             try {
-                listener.onResponse(new Response(GROK_PATTERNS));
+                listener.onResponse(new Response(getGrokPatternsResponse(GROK_PATTERNS, request.sorted())));
             } catch (Exception e) {
                 listener.onFailure(e);
             }
         }
+
+        static Map<String, String> getGrokPatternsResponse(Map<String, String> patterns, boolean sorted) {
+            return sorted ? new TreeMap<>(patterns) : patterns;
+        }
     }
 
     public static class RestAction extends BaseRestHandler {
@@ -129,7 +149,9 @@ public String getName() {
 
         @Override
         protected RestChannelConsumer prepareRequest(RestRequest request, NodeClient client) {
-            return channel -> client.executeLocally(INSTANCE, new Request(), new RestToXContentListener<>(channel));
+            boolean sorted = request.paramAsBoolean("s", false);
+            Request grokPatternsRequest = new Request(sorted);
+            return channel -> client.executeLocally(INSTANCE, grokPatternsRequest, new RestToXContentListener<>(channel));
         }
     }
 }

modules/ingest-common/src/test/java/org/elasticsearch/ingest/common/GrokProcessorGetActionTests.java

@@ -28,17 +28,19 @@
 import org.elasticsearch.common.xcontent.json.JsonXContent;
 import org.elasticsearch.test.ESTestCase;
 
+import java.util.ArrayList;
 import java.util.Collections;
+import java.util.List;
 import java.util.Map;
 
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.core.IsNull.nullValue;
 
 public class GrokProcessorGetActionTests extends ESTestCase {
-    private static final Map<String, String> TEST_PATTERNS = Collections.singletonMap("PATTERN", "foo");
+    private static final Map<String, String> TEST_PATTERNS = Map.of("PATTERN2", "foo2", "PATTERN1", "foo1");
 
     public void testRequest() throws Exception {
-        GrokProcessorGetAction.Request request = new GrokProcessorGetAction.Request();
+        GrokProcessorGetAction.Request request = new GrokProcessorGetAction.Request(false);
         BytesStreamOutput out = new BytesStreamOutput();
         request.writeTo(out);
         StreamInput streamInput = out.bytes().streamInput();
@@ -56,15 +58,23 @@ public void testResponseSerialization() throws Exception {
         assertThat(response.getGrokPatterns(), equalTo(otherResponse.getGrokPatterns()));
     }
 
+    public void testResponseSorting() {
+        Map<String, String> sorted = GrokProcessorGetAction.TransportAction.getGrokPatternsResponse(TEST_PATTERNS, true);
+        List<String> sortedKeys = new ArrayList<>(TEST_PATTERNS.keySet());
+        Collections.sort(sortedKeys);
+        assertThat(new ArrayList<>(sorted.keySet()), equalTo(sortedKeys));
+    }
+
     @SuppressWarnings("unchecked")
     public void testResponseToXContent() throws Exception {
         GrokProcessorGetAction.Response response = new GrokProcessorGetAction.Response(TEST_PATTERNS);
         try (XContentBuilder builder = JsonXContent.contentBuilder()) {
             response.toXContent(builder, ToXContent.EMPTY_PARAMS);
             Map<String, Object> converted = XContentHelper.convertToMap(BytesReference.bytes(builder), false, builder.contentType()).v2();
             Map<String, String> patterns = (Map<String, String>) converted.get("patterns");
-            assertThat(patterns.size(), equalTo(1));
-            assertThat(patterns.get("PATTERN"), equalTo("foo"));
+            assertThat(patterns.size(), equalTo(2));
+            assertThat(patterns.get("PATTERN1"), equalTo("foo1"));
+            assertThat(patterns.get("PATTERN2"), equalTo("foo2"));
         }
     }
 }