added analyze virtual threads command to mcp server

Author: irockel

README.md

@@ -108,6 +108,7 @@ The MCP server exposes the following tools:
 | `get_summary`       | None                      | Returns a summary of all parsed thread dumps (index, name, timestamp, thread/deadlock counts). |
 | `check_deadlocks`   | None                      | Checks for and returns information about any deadlocks detected in the parsed thread dumps.    |
 | `find_long_running` | None                      | Identifies threads that remain in the same state/stack trace across consecutive dumps.         |
+| `analyze_virtual_threads` | None                  | Detects virtual threads where the carrier thread is stuck in application code.                |
 | `clear`             | None                      | Resets the server state and clears the internal thread store for a new log file.               |
 
 #### Troubleshooting
@@ -139,7 +140,7 @@ When you encounter a log file that appears to contain Java thread dumps:
 1. DO NOT try to read or "cat" the entire file if it's large.
 2. Use the `tda-analyzer` MCP toolset.
 3. First, call `parse_log(path="...")` to initialize the analysis.
-4. Use `get_summary()`, `check_deadlocks()`, and `find_long_running()` to perform the analysis.
+4. Use `get_summary()`, `check_deadlocks()`, `find_long_running()`, and `analyze_virtual_threads()` to perform the analysis.
 5. Provide your insights based on the structured data returned by these tools rather than the raw log text.
 ```
 This configuration makes the analysis much faster and significantly reduces token usage.

tda/src/main/java/de/grimmfrost/tda/mcp/HeadlessAnalysisProvider.java

@@ -83,12 +83,10 @@ public List<String> findLongRunningThreads() {
             paths[i] = new TreePath(topNodes.get(i).getPath());
         }
 
-        // AbstractDumpParser.findLongRunningThreads is protected or package private? 
-        // No, it is public in AbstractDumpParser but SunJDKParser might override it.
-        // Actually it's public in AbstractDumpParser.
+        // AbstractDumpParser.findLongRunningThreads is public in AbstractDumpParser.
 
         // We need a parser instance to call findLongRunningThreads
-        // Let's use the first one if possible or just any SunJDKParser
+        // Let's use any SunJDKParser
         SunJDKParser dummyParser = new SunJDKParser(null, threadStore, 0, false, 0, new DateMatcher());
 
         DefaultMutableTreeNode longRunningRoot = new DefaultMutableTreeNode("Long Running Threads");
@@ -106,6 +104,33 @@ public List<String> findLongRunningThreads() {
         return results;
     }
 
+    public List<String> analyzeVirtualThreads() {
+        List<String> results = new ArrayList<>();
+        int totalStuck = 0;
+        for (DefaultMutableTreeNode node : topNodes) {
+            ThreadDumpInfo tdi = (ThreadDumpInfo) node.getUserObject();
+            int stuckCarrierThreads = 0;
+            Category threadsCat = tdi.getThreads();
+            if (threadsCat != null) {
+                int threadCount = threadsCat.getNodeCount();
+                for (int i = 0; i < threadCount; i++) {
+                    DefaultMutableTreeNode threadNode = (DefaultMutableTreeNode) threadsCat.getNodeAt(i);
+                    ThreadInfo ti = (ThreadInfo) threadNode.getUserObject();
+                    if (ti.getContent().contains("carrier thread seems to be stuck in application code")) {
+                        stuckCarrierThreads++;
+                        results.add("Stuck carrier thread in dump '" + tdi.getName() + "': " + ti.getName());
+                    }
+                }
+            }
+            totalStuck += stuckCarrierThreads;
+        }
+
+        if (totalStuck == 0) {
+            results.add("No virtual threads with stuck carrier threads detected in " + topNodes.size() + " dumps.");
+        }
+        return results;
+    }
+
     public void clear() {
         threadStore.clear();
         topNodes.clear();

tda/src/main/java/de/grimmfrost/tda/mcp/MCPServer.java

@@ -91,6 +91,8 @@ private static void handleListTools(JsonObject request) {
 
         tools.add(createTool("find_long_running", "Identifies threads that appear in multiple consecutive thread dumps.", new JsonObject()));
 
+        tools.add(createTool("analyze_virtual_threads", "Detects virtual threads where the carrier thread is stuck in application code.", new JsonObject()));
+
         result.add("tools", gson.toJsonTree(tools));
         sendResponse(request.get("id").getAsInt(), result);
     }
@@ -146,6 +148,8 @@ private static Object handleGenericRequest(String method, JsonObject params) thr
                 return provider.checkForDeadlocks();
             case "find_long_running":
                 return provider.findLongRunningThreads();
+            case "analyze_virtual_threads":
+                return provider.analyzeVirtualThreads();
             case "clear":
                 provider.clear();
                 return "Cleared thread store.";

tda/src/test/java/de/grimmfrost/tda/mcp/HeadlessAnalysisProviderTest.java

@@ -46,4 +46,27 @@ public void testSummary() throws Exception {
         assertEquals(2, summary.size());
         assertTrue(summary.get(0).get("name").toString().contains("Dump"));
     }
+
+    @Test
+    public void testVirtualThreadAnalysis() throws Exception {
+        HeadlessAnalysisProvider provider = new HeadlessAnalysisProvider();
+        String logPath = "src/test/resources/carrier_stuck.log";
+        File logFile = new File(logPath);
+        if (!logFile.exists()) {
+             System.out.println("[DEBUG_LOG] Skip test, carrier_stuck.log not found");
+             return;
+        }
+
+        provider.parseLogFile(logPath);
+        List<String> results = provider.analyzeVirtualThreads();
+        
+        boolean found = false;
+        for (String msg : results) {
+            if (msg.contains("Stuck carrier thread")) {
+                found = true;
+                break;
+            }
+        }
+        assertTrue(found, "Should find stuck carrier thread in carrier_stuck.log");
+    }
 }