Change code, tests, and doc to first match algorithm

Author: tjquinno

docs/src/main/asciidoc/includes/metrics/metrics-config.adoc

@@ -89,7 +89,7 @@ See the <<../../se/open-telemetry.adoc#enabling-automatic-metrics-for-inbound-ht
 endif::se-flavor[]
 
 ==== Selecting REST Endpoints for Automatic Measurement
-You can choose which endpoints to include in Helidon's automatic measurements using the `auto` config section.
+You can choose which endpoints to include in Helidon's automatic measurements using the `auto-http-metrics` config section.
 
 include::{rootdir}/config/io_helidon_webserver_observe_metrics_AutoHttpMetricsConfig.adoc[tag=config,leveloffset=+2]
 
@@ -112,20 +112,20 @@ a| Path-matching expression:
 
 | `methods` | {nbsp} | all HTTP method types | Which HTTP methods match this entry
 
-| `enabled` | {nbsp} | `true` | Whether this entry votes to match requests which match the entry
+| `enabled` | {nbsp} | `true` | Whether requests that match this entry should be measured
 |====
 --
 
 Helidon decides whether to measure incoming requests as follows:
 
-* If you omit the `auto` configuration, Helidon measures all endpoints.
-* If you specify the `auto` configuration, by default Helidon does not measure built-in endpoints such as metrics, health, and openapi. You can add items under  `auto.paths` to control more exactly which endpoints to measure.
+* If you omit the `auto-http-metrics` configuration, Helidon measures all endpoints.
+* If you specify the `auto-http-metrics` configuration, by default Helidon does not measure built-in endpoints such as metrics, health, and openapi. You can add items under  `auto-http-metrics.paths` to control more exactly which endpoints to measure.
 * If you include the  `paths` section, Helidon checks a request against the path entries in order. A given request matches an entry if its path matches the path pattern and its HTTP method is in the `methods` list. If there is no `methods` list for an entry, all HTTP methods match the entry.
-* If a request matches an entry, the entry "votes" whether the request should be measured based on the entry's `enabled` setting.
-* If a request matches multiple entries, the last one voting wins.
-* If a request matches no entries, it is measured.
+* If a request matches an entry, the entry's `enabled` setting determines if the request should be measured.
+* If a request matches multiple entries, the first match wins.
+* If a request matches no entry, it is measured.
 
-The `auto.sockets` setting controls which sockets are included in the measurements; if not set, Helidon measures requests on all sockets.
+The `auto-http-metrics.sockets` setting controls which sockets are included in the measurements; if not set, Helidon measures requests on all sockets.
 
 ifdef::se-flavor[]
 [source,yaml]
@@ -152,13 +152,13 @@ server:
 endif::se-flavor[]
 ifdef::mp-flavor[]
 ----
-server.features.observe.observers.metrics.auto.paths.0.path=/greet        # <1>
-server.features.observe.observers.metrics.auto.paths.0.methods=GET,HEAD
+server.features.observe.observers.metrics.auto-http-metrics.paths.0.path=/greet        # <1>
+server.features.observe.observers.metrics.auto-http-metrics.paths.0.methods=GET,HEAD
 
-server.features.observe.observers.metrics.auto.paths.1.path=/greet/{name} # <2>
-server.features.observe.observers.metrics.auto.paths.1.enabled=false
+server.features.observe.observers.metrics.auto-http-metrics.paths.1.path=/greet/{name} # <2>
+server.features.observe.observers.metrics.auto-http-metrics.paths.1.enabled=false
 
-server.features.observe.observers.metrics.auto.sockets=@default,private   # <3>
+server.features.observe.observers.metrics.auto-http-metrics.sockets=@default,private   # <3>
 ----
 endif::mp-flavor[]
 <1> Measure `/greet` for only `GET` and `HEAD` requests.

webserver/observe/metrics/src/main/java/io/helidon/webserver/observe/metrics/AutoHttpMetricsConfigSupport.java

@@ -54,19 +54,13 @@ static class CustomMethods {
         /**
          * Decides whether the specified HTTP method and path should be measured.
          * <p>
-         * Given a request (actually, its method and path pair), Helidon searches for a matching config element
-         * based on path matching. Each time Helidon finds a path match, it then checks the HTTP methods associated with
-         * that entry. If the request's method appears among the config entry's methods(or if there are no methods explicitly
-         * configured for that path element), then Helidon considers the request a match to that entry. Helidon then saves
-         * that entry's {@code enabled} settings as the latest result for the request and goes on to check the next
-         * configured path entry.
+         * Given a request, we search for a path config that matches the request's path and HTTP method.
+         * We immediately return the {@code enabled} value for the first path config that the request matches.
          * <p>
-         * A given request might match any number of entries, and the last match wins.
-         * <p>
-         * If a request's path matches no configured entry then the request is measured, subject to the next note.
+         * If we find no match, we return true.
          * <p>
          * Helidon automatically prefixes the explicitly-configured path entries with implicit entries for Helidon-provided
-         * endpoints with measurement disabled. Users can enable automatic metrics for sucb an endpoint
+         * endpoints with measurement disabled. Users can enable automatic metrics for such an endpoint
          * by adding explicit configuration for it with {@code enabled} set to {@code true}.
          *
          * @param config automatic metrics configuration
@@ -81,14 +75,12 @@ static boolean isMeasured(AutoHttpMetricsConfig config, Method method, UriPath u
                 return true;
             }
 
-            boolean latestResult = true;
-
             for (AutoHttpMetricsPathConfig cfg : config.effectivePathConfigs()) {
-                if (cfg.matchesPath(uriPath)) {
-                    latestResult = cfg.matchesMethod(method) == cfg.enabled();
+                if (cfg.matchesPath(uriPath) && cfg.matchesMethod(method)) {
+                    return cfg.enabled();
                 }
             }
-            return latestResult;
+            return true;
         }
 
         /**
@@ -113,8 +105,8 @@ static class BuilderDecorator implements Prototype.BuilderDecorator<AutoHttpMetr
         @Override
         public void decorate(AutoHttpMetricsConfig.BuilderBase<?, ?> target) {
 
-            var fullList = new ArrayList<>(MEASUREMENT_DISABLED_HELIDON_ENDPOINTS);
-            fullList.addAll(target.autoHttpMetricsPathConfigs());
+            var fullList = new ArrayList<>(target.autoHttpMetricsPathConfigs());
+            fullList.addAll(MEASUREMENT_DISABLED_HELIDON_ENDPOINTS);
             target.effectivePathConfigs(fullList);
         }
     }

webserver/observe/metrics/src/test/java/io/helidon/webserver/observe/metrics/TestAutoMetricsConfig.java

@@ -21,6 +21,7 @@
 import io.helidon.config.Config;
 import io.helidon.config.ConfigSources;
 import io.helidon.http.Method;
+import io.helidon.http.PathMatchers;
 
 import org.junit.jupiter.api.Test;
 
@@ -39,24 +40,28 @@ void testAutoMetricsConfig() {
                         metrics:
                           auto-http-metrics:
                             paths:
-                              - path: "/greet"
-                                methods: ["GET","HEAD"]
                               - path: "/greet/{name}"
                                 methods: ["GET","OPTIONS"]
+                              - path: "/greet"
+                                methods: ["GET","HEAD"]
                               - path: "/stuff"
                                 methods: ["HEAD","OPTIONS"]
                                 enabled: false
                               - path: "/hi"
                                 enabled: false
+                              - path: "/another/{name}"
+                                methods: ["PUT","POST","OPTIONS"]
+                                enabled: false
+                              - path: "/another/{name}"
                 """;
-        var config = AutoHttpMetricsConfig.create(Config.just(ConfigSources.create(configText, MediaTypes.APPLICATION_X_YAML))
-                                             .get("server.features.observe.observers.metrics.auto-http-metrics"));
+        var configFromText = Config.just(ConfigSources.create(configText, MediaTypes.APPLICATION_X_YAML))
+                .get("server.features.observe.observers.metrics.auto-http-metrics");
+        var config = AutoHttpMetricsConfig.create(configFromText);
 
         assertThat("GET /greet", config.isMeasured(Method.GET, UriPath.create("/greet")), is(true));
-        assertThat("PUT /greet", config.isMeasured(Method.PUT, UriPath.create("/greet")), is(false));
+        assertThat("PUT /greet", config.isMeasured(Method.PUT, UriPath.create("/greet")), is(true));
 
         assertThat("GET /greet/Joe",  config.isMeasured(Method.GET, UriPath.create("/greet/Joe")), is(true));
-        assertThat("GET /other", config.isMeasured(Method.GET, UriPath.create("/other")), is(true));
 
         assertThat("GET /hi", config.isMeasured(Method.GET, UriPath.create("/hi")), is(false));
 
@@ -65,6 +70,29 @@ void testAutoMetricsConfig() {
         assertThat("GET /stuff", config.isMeasured(Method.GET, UriPath.create("/stuff")), is(true));
         assertThat("HEAD /stuff", config.isMeasured(Method.HEAD, UriPath.create("/stuff")), is(false));
 
+        assertThat("PUT /another/Joe", config.isMeasured(Method.PUT, UriPath.create("/another/Joe")), is(false));
+        assertThat("GET /another/Joe", config.isMeasured(Method.GET, UriPath.create("/another/Joe")), is(true));
+
+        assertThat("GET /undeclared", config.isMeasured(Method.GET, UriPath.create("/unknown")), is(true));
+
+        assertThat("GET /observe/metrics",
+                   config.isMeasured(Method.GET, UriPath.create("/observe/metrics")),
+                   is(false));
+
+        assertThat("GET /metrics", config.isMeasured(Method.GET, UriPath.create("/metrics")), is(false));
+
+        var withCatchAll = AutoHttpMetricsConfig.builder()
+                .config(configFromText)
+                .addAutoHttpMetricsPathConfig(AutoHttpMetricsPathConfig.builder()
+                                                      .path(PathMatchers.create("/*"))
+                                                      .enabled(false)
+                                                      .build())
+                .build();
+
+        assertThat("PUT /greet with catchall", withCatchAll.isMeasured(Method.PUT, UriPath.create("/greet")), is(false));
+        assertThat("GET /undeclared with catchall", withCatchAll.isMeasured(Method.GET, UriPath.create("/undeclared")), is(false));
+        assertThat("GET /another/Joe", config.isMeasured(Method.GET, UriPath.create("/another/Joe")), is(true));
+
     }
 
     @Test