refactor(perf-analyzer): make GitHubSourceCodeTool a singleton

Author: Yuriy Bezsonov

apps/perf-analyzer/src/main/java/com/example/perf/analyzer/AiService.java

@@ -3,19 +3,16 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.ai.chat.client.ChatClient;
-import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 
 /**
  * Spring AI + Amazon Bedrock Converse. Builds one {@link ChatClient}
- * configured with the system prompt and the always-registered
- * {@link PyroscopeTool}, then per-analysis layers in a fresh
- * {@link GitHubSourceCodeTool} when the target workload advertises a
- * GitHub repo via pod annotation or task tag.
+ * configured with the system prompt and the two tools the model calls:
+ * {@link PyroscopeTool} and {@link GitHubSourceCodeTool}.
  *
- * Per-analysis tool registration lets the analyzer serve many workloads
- * whose sources live in different repositories without any environment
- * configuration on the analyzer side.
+ * Both tools are singletons. Per-analysis context (workload service name,
+ * time window, repo coordinates) is communicated to the model through the
+ * user prompt — the model passes those values back when it calls a tool.
  */
 @Service
 public class AiService {
@@ -50,44 +47,33 @@ public class AiService {
         """;
 
     private final ChatClient chatClient;
-    private final String githubToken;
 
     public AiService(
         ChatClient.Builder chatClientBuilder,
         PyroscopeTool pyroscopeTool,
-        @Value("${GITHUB_TOKEN:}") String githubToken
+        GitHubSourceCodeTool githubSourceCodeTool
     ) {
-        this.githubToken = githubToken;
         this.chatClient = chatClientBuilder
             .defaultSystem(SYSTEM_PROMPT)
-            .defaultTools(pyroscopeTool)
+            .defaultTools(pyroscopeTool, githubSourceCodeTool)
             .build();
     }
 
     /** Runs the analysis and returns the Markdown report content. */
     public String analyze(AnalysisService.AnalysisContext ctx) {
-        var sourceCodeTool = buildSourceCodeTool(ctx);
-        var prompt = buildPrompt(ctx, sourceCodeTool != null);
+        var hasRepo = ctx.githubRepo() != null && !ctx.githubRepo().isBlank();
+        var prompt = buildPrompt(ctx, hasRepo);
 
-        logger.info("Sending analysis request to Amazon Bedrock: analysisId={} service={} sourceTool={}",
-            ctx.analysisId(), ctx.request().service(), sourceCodeTool != null);
+        logger.info("Sending analysis request to Amazon Bedrock: analysisId={} service={} repo={}",
+            ctx.analysisId(), ctx.request().service(), hasRepo ? ctx.githubRepo() : "(none)");
 
-        var spec = chatClient.prompt().user(prompt);
-        if (sourceCodeTool != null) {
-            spec = spec.tools(sourceCodeTool);
-        }
-        var response = spec.call().content();
+        var response = chatClient.prompt().user(prompt).call().content();
 
         logger.info("Received analysis response from Amazon Bedrock: analysisId={} length={}",
             ctx.analysisId(), response == null ? 0 : response.length());
         return response == null ? "# Analysis\n\n_Model returned no content._\n" : response;
     }
 
-    private GitHubSourceCodeTool buildSourceCodeTool(AnalysisService.AnalysisContext ctx) {
-        if (ctx.githubRepo() == null || ctx.githubRepo().isBlank()) return null;
-        return new GitHubSourceCodeTool(ctx.githubRepo(), ctx.githubPath(), githubToken);
-    }
-
     String buildPrompt(AnalysisService.AnalysisContext ctx, boolean sourceCodeAvailable) {
         var r = ctx.request();
         var sb = new StringBuilder();
@@ -152,27 +138,36 @@ blocking waits and contention (wall view). Flag resource pressure,
             Be concise.
             """);
 
+        sb.append("""
+
+            ---
+
+            You have a Pyroscope query tool you can invoke to request
+            additional time windows or narrower label selectors if you need
+            to confirm a hypothesis before writing the report.
+            """);
+
         if (sourceCodeAvailable) {
             sb.append("""
 
-                ---
+                You also have a GitHub source-code tool. Use it to look up
+                the actual source of methods that appear in Pyroscope top
+                functions, JFR events, or the thread dump. The target
+                workload's source lives at:
 
-                You have a source code tool. Use it to look up the actual
-                source of methods that appear in Pyroscope top functions,
-                JFR events, or the thread dump. In your findings and
-                recommendations, reference specific file paths, class names
-                and line numbers. Provide concrete code fixes — show the
-                current problematic code and the recommended replacement.
+                """);
+            sb.append("- repo: `").append(ctx.githubRepo()).append("`\n");
+            var path = ctx.githubPath() == null ? "" : ctx.githubPath();
+            sb.append("- pathPrefix: `").append(path).append("`\n\n");
+            sb.append("""
+                Pass those values along with the file path on every call.
+                In your findings and recommendations, reference specific
+                file paths, class names and line numbers. Provide concrete
+                code fixes — show the current problematic code and the
+                recommended replacement.
                 """);
         }
 
-        sb.append("""
-
-            You also have a Pyroscope query tool you can invoke to request
-            additional time windows or narrower label selectors if you need
-            to confirm a hypothesis before writing the report.
-            """);
-
         return sb.toString();
     }
 

apps/perf-analyzer/src/main/java/com/example/perf/analyzer/GitHubSourceCodeTool.java

@@ -4,6 +4,8 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.ai.tool.annotation.Tool;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
 import org.springframework.web.client.RestClient;
 
 import java.util.Base64;
@@ -12,66 +14,64 @@
  * Spring AI @Tool: fetch source code from a GitHub repository via the
  * REST API.
  *
- * The repo coordinates are per-analysis — the target workload advertises
- * them via the pod annotation {@code perf-profile/github-repo} (or the
- * ECS task tag {@code perf-profile:github-repo}). The analyzer constructs
- * a fresh instance each request, picking up whichever workload's repo
- * coordinates the current analysis context carries.
+ * Singleton @Component, mirroring {@link PyroscopeTool}. Per-analysis
+ * coordinates (repo, pathPrefix) are passed by the model on each call;
+ * the analyzer surfaces the right values to the model through the prompt.
  *
- * Compare {@link PyroscopeTool}, which is a top-level @Component because
- * {@link AnalysisService} also invokes it directly for the pre-fetched
- * prompt sections.
+ * The optional GitHub PAT for private repositories comes from the
+ * GITHUB_TOKEN environment variable.
  */
+@Component
 public class GitHubSourceCodeTool {
 
     private static final Logger logger = LoggerFactory.getLogger(GitHubSourceCodeTool.class);
     private static final ObjectMapper MAPPER = new ObjectMapper();
 
     private final RestClient restClient;
-    private final String repoPath;
 
-    /**
-     * @param repo   "{owner}/{name}" (e.g. "aws-samples/java-on-aws")
-     * @param path   optional path-prefix inside the repo (e.g. "apps/unicorn-store-spring")
-     * @param token  optional GitHub PAT for private repos
-     */
-    public GitHubSourceCodeTool(String repo, String path, String token) {
-        if (repo == null || repo.isBlank()) {
-            throw new IllegalArgumentException("repo must not be blank");
-        }
+    public GitHubSourceCodeTool(@Value("${GITHUB_TOKEN:}") String githubToken) {
         var builder = RestClient.builder()
-            .baseUrl("https://api.github.com/repos/" + repo.replaceAll("/$", ""))
+            .baseUrl("https://api.github.com")
             .defaultHeader("Accept", "application/vnd.github.v3+json")
             .defaultHeader("User-Agent", "perf-analyzer");
-        if (token != null && !token.isBlank()) {
-            builder.defaultHeader("Authorization", "token " + token);
+        if (githubToken != null && !githubToken.isBlank()) {
+            builder.defaultHeader("Authorization", "token " + githubToken);
         }
         this.restClient = builder.build();
-        this.repoPath = (path != null && !path.isBlank())
-            ? path.replaceAll("/$", "") : "";
     }
 
     @Tool(description = """
-        Fetch a source code file from the application GitHub repository.
-        Provide the path relative to the application root, e.g.
-        src/main/java/com/unicorn/store/service/UnicornService.java — the
-        repository base path is prepended automatically.
+        Fetch a source code file from a GitHub repository.
+        Parameters:
+          repo        - "{owner}/{name}" (e.g. "aws-samples/java-on-aws").
+          pathPrefix  - optional path prefix inside the repo for the
+                        application root (e.g. "apps/unicorn-store-spring").
+                        Pass an empty string if not applicable.
+          filePath    - path relative to the application root, e.g.
+                        "src/main/java/com/unicorn/store/service/UnicornService.java".
         Use this to look up Java source files referenced in stack traces,
         thread dumps, and JFR event summaries so recommendations can cite
         file paths and line numbers.
         """)
-    public String fetchSourceCode(String filePath) {
-        var fullPath = repoPath.isEmpty() ? filePath : repoPath + "/" + filePath;
+    public String fetchSourceCode(String repo, String pathPrefix, String filePath) {
+        if (repo == null || repo.isBlank()) {
+            return "Source code not available: repo not provided.";
+        }
+        var prefix = (pathPrefix == null || pathPrefix.isBlank())
+            ? "" : pathPrefix.replaceAll("/$", "");
+        var fullPath = prefix.isEmpty() ? filePath : prefix + "/" + filePath;
+        var uri = "/repos/" + repo.replaceAll("/$", "") + "/contents/" + fullPath;
         try {
             var json = restClient.get()
-                .uri("/contents/{path}", fullPath)
+                .uri(uri)
                 .retrieve()
                 .body(String.class);
             var node = MAPPER.readTree(json);
             var encoded = node.get("content").asText();
             return new String(Base64.getMimeDecoder().decode(encoded));
         } catch (Exception e) {
-            logger.warn("Failed to fetch source code for {}: {}", fullPath, e.getMessage());
+            logger.warn("Failed to fetch source code repo={} path={}: {}",
+                repo, fullPath, e.getMessage());
             return "Source code not available: " + e.getMessage();
         }
     }