feat(agent): Optimize class exclusion with PrefixTrie

Replaced the linear search for class exclusions in `AppMapPackage`
with a `PrefixTrie` for `O(M)` lookup performance, where M is the
length of the class name. This significantly improves performance,
especially with large exclusion lists.

Exclusion patterns can now be specified relative to the package path
in `appmap.yml`, improving configuration clarity. Backward
compatibility is maintained by supporting both relative and fully
qualified exclusion patterns.

The original `exclude` array was preserved for debugging and logging
purposes to prevent breaking existing functionality in `AppMapConfig`.

Author: dividedmind

agent/src/main/java/com/appland/appmap/config/AppMapPackage.java

@@ -11,6 +11,8 @@
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonProperty;
 
+import com.appland.appmap.util.PrefixTrie;
+
 import javassist.CtBehavior;
 public class AppMapPackage {
   private static final TaggedLogger logger = AppMapConfig.getLogger(null);
@@ -20,6 +22,7 @@ public class AppMapPackage {
   public String[] exclude = new String[] {};
   public boolean shallow = false;
   public Boolean allMethods = true;
+  private final PrefixTrie excludeTrie = new PrefixTrie();
 
   @JsonCreator
   public AppMapPackage(@JsonProperty("path") String path,
@@ -29,7 +32,20 @@ public AppMapPackage(@JsonProperty("path") String path,
     this.path = path;
     this.exclude = exclude == null ? new String[] {} : exclude;
     this.shallow = shallow != null && shallow;
-    this.allMethods = allMethods == null ? true : allMethods;
+    this.allMethods = allMethods == null || allMethods;
+
+    if (exclude != null) {
+      final String packagePrefix = this.path + ".";
+      for (String exclusion : exclude) {
+        if (exclusion.startsWith(packagePrefix)) {
+          // Absolute path, strip the package path and add the rest
+          this.excludeTrie.insert(exclusion.substring(packagePrefix.length()));
+        } else {
+          // Relative path, add as-is
+          this.excludeTrie.insert(exclusion);
+        }
+      }
+    }
   }
 
   public static class LabelConfig {
@@ -77,7 +93,7 @@ public boolean matches(String className, String methodName) {
 
   /**
    * Check if a class/method is included in the configuration.
-   * 
+   *
    * @param canonicalName the canonical name of the class/method to be checked
    * @return {@code true} if the class/method is included in the configuration. {@code false} if it
    *         is not included or otherwise explicitly excluded.
@@ -119,39 +135,37 @@ public LabelConfig find(FullyQualifiedName canonicalName) {
     return null;
   }
 
+  private String getRelativeClassName(String fqcn) {
+    final String packagePrefix = this.path + ".";
+    if (fqcn.startsWith(packagePrefix)) {
+      return fqcn.substring(packagePrefix.length());
+    }
+    return fqcn;
+  }
+
   /**
    * Checks whether the behavior is explicitly excluded
    *
    * @param behavior the behavior to be checked
    * @return {@code true} if the behavior is excluded
    */
   public Boolean excludes(CtBehavior behavior) {
-    final String fqClass = behavior.getDeclaringClass().getName();
-    String candidateName = null;
-    for (String exclusion : this.exclude) {
-      if (fqClass.startsWith(exclusion)) {
-        return true;
-      } else {
-        if (candidateName == null) {
-          candidateName = fqClass + "." + behavior.getName();
-        }
-
-        if (candidateName.startsWith(exclusion.replace('#', '.'))) {
-          return true;
-        }
-      }
+    String fqClass = behavior.getDeclaringClass().getName();
+    String relativeClassName = getRelativeClassName(fqClass);
+    if (this.excludeTrie.startsWith(relativeClassName)) {
+      return true;
     }
 
-    return false;
+    // Also check method-specific exclusions
+    String methodName = behavior.getName();
+    String relativeMethodName = String.format("%s.%s", relativeClassName, methodName)
+        .replace('#', '.');
+    return this.excludeTrie.startsWith(relativeMethodName);
   }
 
   public Boolean excludes(FullyQualifiedName canonicalName) {
-    for (String exclusion : this.exclude) {
-      if (canonicalName.toString().startsWith(exclusion)) {
-        return true;
-      }
-    }
-
-    return false;
+    String fqcn = canonicalName.toString();
+    String relativeName = getRelativeClassName(fqcn);
+    return this.excludeTrie.startsWith(relativeName);
   }
 }

agent/src/main/java/com/appland/appmap/util/PrefixTrie.java

@@ -0,0 +1,58 @@
+package com.appland.appmap.util;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * A simple Trie (Prefix Tree) for efficient prefix-based string matching.
+ * This is used to check if a class name matches any of the exclusion patterns.
+ */
+public class PrefixTrie {
+    private static class TrieNode {
+        Map<Character, TrieNode> children = new HashMap<>();
+        boolean isEndOfWord = false;
+    }
+
+    private final TrieNode root;
+
+    public PrefixTrie() {
+        root = new TrieNode();
+    }
+
+    /**
+     * Inserts a word into the Trie.
+     * @param word The word to insert.
+     */
+    public void insert(String word) {
+        TrieNode current = root;
+        for (char ch : word.toCharArray()) {
+            current = current.children.computeIfAbsent(ch, c -> new TrieNode());
+        }
+        current.isEndOfWord = true;
+    }
+
+    /**
+     * Checks if any prefix of the given word exists in the Trie.
+     * For example, if "java." is in the Trie, this will return true for "java.lang.String".
+     * @param word The word to check.
+     * @return {@code true} if a prefix of the word is found in the Trie, {@code false} otherwise.
+     */
+    public boolean startsWith(String word) {
+        TrieNode current = root;
+        for (int i = 0; i < word.length(); i++) {
+            char ch = word.charAt(i);
+            current = current.children.get(ch);
+            if (current == null) {
+                return false; // No prefix match
+            }
+            if (current.isEndOfWord) {
+                // We've found a stored pattern that is a prefix of the word.
+                // e.g., Trie has "java." and word is "java.lang.String"
+                return true;
+            }
+        }
+        // The word itself is a prefix or an exact match for a pattern in the Trie
+        // e.g., Trie has "java.lang" and word is "java.lang"
+        return current.isEndOfWord;
+    }
+}