mcp-jvm-diagnostics 0.1.3 → 0.1.5

package/README.md

@@ -9,7 +9,7 @@ A Model Context Protocol (MCP) server that gives AI assistants the ability to an
 
 JVM diagnostic MCP servers exist (TDA, jfr-mcp, Arthas) — but they're all **Java-based**, requiring a JVM runtime just to diagnose JVM problems. This tool runs on **Node.js** via `npx` — no JVM, no Docker, no SSH.
 
-It analyzes **offline** artifacts (thread dumps, GC logs, heap histograms) rather than requiring a running JVM. Paste a thread dump or GC log and get instant analysis. Part of the [MCP Java Backend Suite](https://www.npmjs.com/package/mcp-java-backend-suite) — 5 tools covering databases, JVM, migrations, Spring Boot, and Redis for Java backend developers.
+It analyzes **offline** artifacts (thread dumps, GC logs, heap histograms) rather than requiring a running JVM. Paste a thread dump or GC log and get instant analysis.
 
 ## Features
 
@@ -160,6 +160,13 @@ Add these JVM flags to your application:
 - **HotSpot/OpenJDK only**: Parser targets HotSpot/OpenJDK thread dump format. GraalVM native-image or Eclipse OpenJ9 dumps may parse incompletely.
 - **Classloader leak detection**: Heap analysis flags growing ClassLoader instances but cannot definitively prove a leak without memory profiler data.
 
+## Part of the MCP Java Backend Suite
+
+- [mcp-db-analyzer](https://www.npmjs.com/package/mcp-db-analyzer) — PostgreSQL/MySQL/SQLite schema analysis
+- [mcp-spring-boot-actuator](https://www.npmjs.com/package/mcp-spring-boot-actuator) — Spring Boot health, metrics, and bean analysis
+- [mcp-redis-diagnostics](https://www.npmjs.com/package/mcp-redis-diagnostics) — Redis memory, slowlog, and client diagnostics
+- [mcp-migration-advisor](https://www.npmjs.com/package/mcp-migration-advisor) — Flyway/Liquibase migration risk analysis
+
 ## License
 
 MIT

package/build/index.js

@@ -12,7 +12,7 @@ import { compareHeapHistos } from "./analyzers/heap-diff.js";
 import { parseJfrSummary } from "./parsers/jfr-summary.js";
 // Handle --help
 if (process.argv.includes("--help") || process.argv.includes("-h")) {
-    console.log(`mcp-jvm-diagnostics v0.1.0 — MCP server for JVM diagnostics
+    console.log(`mcp-jvm-diagnostics v0.1.5 — MCP server for JVM diagnostics
 
 Usage:
   mcp-jvm-diagnostics [options]
@@ -21,8 +21,8 @@ Options:
   --help, -h   Show this help message
 
 Tools provided:
-  analyze_thread_dump   Parse thread dump, detect deadlocks and contention
-  analyze_gc_log        Parse GC log, detect pressure and tuning opportunities
+  analyze_thread_dump   Parse thread dump, detect deadlocks and contention (platform + virtual threads)
+  analyze_gc_log        Parse GC log, detect pressure and tuning (G1, ZGC, Parallel, Shenandoah)
   analyze_heap_histo    Parse jmap -histo output, detect memory leak candidates
   compare_heap_histos   Compare two jmap histos to detect memory growth
   analyze_jfr           Parse JFR summary output, detect performance hotspots
@@ -31,10 +31,10 @@ Tools provided:
 }
 const server = new McpServer({
     name: "mcp-jvm-diagnostics",
-    version: "0.1.0",
+    version: "0.1.4",
 });
 // --- Tool: analyze_thread_dump ---
-server.tool("analyze_thread_dump", "Parse a JVM thread dump (jstack output) and analyze thread states, detect deadlocks, identify lock contention hotspots, and find thread starvation patterns.", {
+server.tool("analyze_thread_dump", "Parse a JVM thread dump (jstack output) and analyze thread states, detect deadlocks, identify lock contention hotspots, and find thread starvation patterns. Handles both platform threads and virtual threads (Java 21+).", {
     thread_dump: z
         .string()
         .describe("The full thread dump text (from jstack, kill -3, or VisualVM)"),
@@ -121,7 +121,7 @@ server.tool("analyze_thread_dump", "Parse a JVM thread dump (jstack output) and
     }
 });
 // --- Tool: analyze_gc_log ---
-server.tool("analyze_gc_log", "Parse a JVM GC log and analyze garbage collection patterns, pause times, allocation rates, and memory pressure. Supports G1, ZGC, and Parallel GC formats.", {
+server.tool("analyze_gc_log", "Parse a JVM GC log and analyze garbage collection patterns, pause times, allocation rates, and memory pressure. Supports G1, ZGC, Parallel, Serial, and Shenandoah GC formats.", {
     gc_log: z
         .string()
         .describe("The GC log text (from -Xlog:gc* or -verbose:gc)"),

package/build/parsers/gc-log.js

@@ -14,6 +14,14 @@ const UNIFIED_CONCURRENT_RE = /\[(\d+[.,]\d+)s\].*?GC\(\d+\)\s+(Concurrent\s+\S+
 const LEGACY_GC_RE = /\[(Full )?GC\s*\(([^)]+)\)\s+(\d+)K->(\d+)K\((\d+)K\),\s+(\d+[.,]\d+)\s+secs\]/;
 // ZGC format: [0.123s][info][gc] GC(0) Garbage Collection (Warmup) 24M(1%)->8M(0%) 1.234ms
 const ZGC_RE = /\[(\d+[.,]\d+)s\].*?GC\(\d+\)\s+Garbage Collection\s+\([^)]+\)\s+(\d+)M\(\d+%\)->(\d+)M\(\d+%\)\s+(\d+[.,]\d+)ms/;
+// Shenandoah pause format: [0.521s][info][gc] GC(0) Pause Init Mark 2.606ms
+// Pauses include: Pause Init Mark, Pause Final Mark, Pause Init Update Refs, Pause Final Update Refs, Pause Full
+const SHENANDOAH_PAUSE_RE = /\[(\d+[.,]\d+)s\].*?GC\(\d+\)\s+(Pause\s+(?:Init|Final)\s+\S+(?:\s+\S+)?|Pause Full(?:\s+\([^)]*\))?)\s+(\d+[.,]\d+)ms/;
+// Parallel GC verbose:gc with region detail (-verbose:gc on Java 8):
+// [GC (Allocation Failure) [PSYoungGen: 65536K->5432K(76288K)] 65536K->5432K(251392K), 0.0123456 secs]
+// [Full GC (Ergonomics) [PSYoungGen: 5K->0K(76K)] [ParOldGen: 100K->50K(175K)] 105K->50K(251K), [Metaspace: 10K->10K(1056K)], 0.5679 secs]
+// The (?:\s*\[[^\]]+\])+ skips one or more region detail blocks (PSYoungGen, ParOldGen, Metaspace before secs).
+const PARALLEL_REGION_GC_RE = /\[(Full\s+)?GC\s*\([^)]+\)(?:\s*\[[^\]]+\])+\s*(\d+)K->(\d+)K\((\d+)K\),(?:\s*\[[^\]]+\],)?\s*(\d+[.,]\d+)\s+secs/;
 export function parseGcLog(text) {
     const lines = text.replace(/\r\n/g, "\n").split("\n");
     const events = [];
@@ -75,6 +83,19 @@ export function parseGcLog(text) {
             });
             continue;
         }
+        // Try Shenandoah pause format (no heap sizes in pause events)
+        const shenandoahMatch = line.match(SHENANDOAH_PAUSE_RE);
+        if (shenandoahMatch) {
+            events.push({
+                timestamp: parseFloat(shenandoahMatch[1].replace(",", ".")),
+                type: shenandoahMatch[2].trim(),
+                pauseMs: parseFloat(shenandoahMatch[3].replace(",", ".")),
+                heapBeforeMb: 0,
+                heapAfterMb: 0,
+                heapTotalMb: 0,
+            });
+            continue;
+        }
         // Try legacy format
         const legacyMatch = line.match(LEGACY_GC_RE);
         if (legacyMatch) {
@@ -87,6 +108,20 @@ export function parseGcLog(text) {
                 heapAfterMb: Math.round(parseInt(legacyMatch[4], 10) / 1024),
                 heapTotalMb: Math.round(parseInt(legacyMatch[5], 10) / 1024),
             });
+            continue;
+        }
+        // Try Parallel GC verbose:gc with PSYoungGen/ParOldGen region blocks
+        const parallelRegionMatch = line.match(PARALLEL_REGION_GC_RE);
+        if (parallelRegionMatch) {
+            const isFull = !!parallelRegionMatch[1];
+            events.push({
+                timestamp: 0,
+                type: isFull ? "Pause Full" : "Pause Young",
+                pauseMs: parseFloat(parallelRegionMatch[5].replace(",", ".")) * 1000,
+                heapBeforeMb: Math.round(parseInt(parallelRegionMatch[2], 10) / 1024),
+                heapAfterMb: Math.round(parseInt(parallelRegionMatch[3], 10) / 1024),
+                heapTotalMb: Math.round(parseInt(parallelRegionMatch[4], 10) / 1024),
+            });
         }
     }
     // Calculate time span

package/build/parsers/jfr-summary.js

@@ -110,6 +110,11 @@ function analyzeJfrEvents(events, totalEvents, totalSize) {
         issues.push(`${monitorEnter.count.toLocaleString()} monitor enter events — significant lock contention.`);
         recommendations.push("Use `analyze_thread_dump` to identify contention hotspots and consider lock-free alternatives.");
     }
+    // Check for threads spending time in Object.wait() — indicates producer-consumer imbalance
+    if (monitorWait && monitorWait.count > 2000) {
+        issues.push(`${monitorWait.count.toLocaleString()} Object.wait() events — threads frequently waiting for notifications. Producers may be slower than consumers.`);
+        recommendations.push("Profile the producer side of producer-consumer queues. Consider bounded queues with backpressure or increasing producer thread count.");
+    }
     // Check for thread starts (churn)
     const threadStart = byName.get("jdk.ThreadStart");
     if (threadStart && threadStart.count > 200) {

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "mcp-jvm-diagnostics",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "MCP server for JVM diagnostics — analyze thread dumps, detect deadlocks, parse GC logs, and get JVM tuning recommendations",
+  "mcpName": "io.github.dmitriusan/mcp-jvm-diagnostics",
   "author": "Dmytro Lisnichenko",
   "type": "module",
   "main": "./build/index.js",