support checking for match after the prefix (#1099)

For patterns where the prefix is extracted and verified
before values are checked against the full matcher, we do
not need to recheck the prefix. This change adds a method
to the pattern matcher to allow bypassing the prefix and
just matching against the remaining part of the pattern.

spectator-api/src/main/java/com/netflix/spectator/impl/PatternMatcher.java

@@ -46,6 +46,15 @@ public interface PatternMatcher {
    */
   boolean matches(String str);
 
+  /**
+   * Returns true if the passed in string matches the pattern after the prefix. This method
+   * can be used to more efficiently check the value if the {@link #prefix()} was already
+   * verified.
+   */
+  default boolean matchesAfterPrefix(String str) {
+    return matches(str);
+  }
+
   /**
    * Returns a fixed string prefix for the pattern if one is available. This can be used
    * with indexed data to help select a subset of values that are possible matches. If the

spectator-api/src/main/java/com/netflix/spectator/impl/matcher/SeqMatcher.java

@@ -73,6 +73,20 @@ public int matches(String str, int start, int length) {
     return pos;
   }
 
+  @Override
+  public boolean matchesAfterPrefix(String str) {
+    if (matchers[0] instanceof StartsWithMatcher) {
+      final int end = str.length();
+      int pos = matchers[0].prefix().length();
+      for (int i = 1; i < matchers.length && pos >= 0; ++i) {
+        pos = matchers[i].matches(str, pos, end - pos);
+      }
+      return pos >= 0;
+    } else {
+      return matches(str);
+    }
+  }
+
   @Override
   public String prefix() {
     return matchers[0].prefix();

spectator-api/src/main/java/com/netflix/spectator/impl/matcher/StartsWithMatcher.java

@@ -53,6 +53,11 @@ public int matches(String str, int start, int length) {
     return matched ? pattern.length() : Constants.NO_MATCH;
   }
 
+  @Override
+  public boolean matchesAfterPrefix(String str) {
+    return true;
+  }
+
   @Override
   public String prefix() {
     return pattern;

spectator-api/src/test/java/com/netflix/spectator/impl/matcher/AbstractPatternMatcherTest.java

@@ -65,6 +65,18 @@ public void prefix() {
     Assertions.assertEquals("abc", PatternMatcher.compile("^[a][b][c]+").prefix());
   }
 
+  @Test
+  public void matchesAfterPrefix() {
+    // StartsWithMatcher, bar case should match because it will not get checked and we trust
+    // that the caller has already verified the prefix.
+    Assertions.assertTrue(PatternMatcher.compile("^abc").matchesAfterPrefix("abcdef"));
+    Assertions.assertTrue(PatternMatcher.compile("^abc").matchesAfterPrefix("bardef"));
+
+    // SeqMatcher
+    Assertions.assertTrue(PatternMatcher.compile("^abc").matchesAfterPrefix("abc[d-f]"));
+    Assertions.assertTrue(PatternMatcher.compile("^abc").matchesAfterPrefix("bar[d-f]"));
+  }
+
   @Test
   public void startAnchor() {
     testRE("^abc", "abcdef");

spectator-reg-atlas/src/main/java/com/netflix/spectator/atlas/impl/QueryIndex.java

@@ -499,7 +499,7 @@ public void forEachMatch(Function<String, String> tags, Consumer<T> consumer) {
           if (!otherChecks.isEmpty()) {
             List<QueryIndex<T>> tmp = new ArrayList<>();
             otherChecksTree.forEach(v, kq -> {
-              if (kq.matches(v)) {
+              if (matches(kq, v)) {
                 QueryIndex<T> idx = otherChecks.get(kq);
                 if (idx != null) {
                   tmp.add(idx);
@@ -536,6 +536,15 @@ public void forEachMatch(Function<String, String> tags, Consumer<T> consumer) {
     }
   }
 
+  private boolean matches(Query.KeyQuery kq, String value) {
+    if (kq instanceof Query.Regex) {
+      Query.Regex re = (Query.Regex) kq;
+      return re.pattern().matchesAfterPrefix(value);
+    } else {
+      return kq.matches(value);
+    }
+  }
+
   /**
    * Find hot spots in the index where there is a large set of linear matches, e.g. a bunch
    * of regex queries for a given key.