jvm tools

java -jar jstall.jar status <pid>
# Or match by JVM name instead of PID
java -jar jstall.jar status MyApplication

java -jar jstall.jar deadlock <pid>

java -jar jstall.jar status <pid> --intelligent-filter

java -jar jstall.jar threads --live <pid>

java -jar jstall.jar most-work --dumps 5 <pid>
# Show only top 3 threads
java -jar jstall.jar most-work --dumps 5 --top=3 <pid>

java -jar jstall.jar flame --duration=30 --open <pid>

java -jar jstall.jar status <pid> | grep -A 20 "Heap"

java -jar jstall.jar record <pid> --output before.zip
sleep 60
java -jar jstall.jar record <pid> --output after.zip
java -jar jstall.jar status before.zip
java -jar jstall.jar status after.zip

jcmd <pid> GC.heap_dump heap.hprof

java -jar jstall.jar most-work <pid>
# Take 3 dumps for a more accurate picture
java -jar jstall.jar most-work --dumps 3 <pid>
# Show only the top 5 threads
java -jar jstall.jar most-work --top=5 <pid>

java -jar jstall.jar flame <pid>
# Record for 30 seconds
java -jar jstall.jar flame --duration=30 <pid>
# Open in browser automatically
java -jar jstall.jar flame --open <pid>

java -jar jstall.jar record <pid> --output diagnostics.zip
# Replay later
java -jar jstall.jar status diagnostics.zip
java -jar jstall.jar most-work diagnostics.zip

# Via cf-cli-java-plugin
cf java jstall $APP_NAME
cf java jstall $APP_NAME --args 'deadlock all'
cf java jstall $APP_NAME --args 'most-work --dumps 3 all'
cf java jstall $APP_NAME --args 'flame all'

# Or directly with jstall
java -jar jstall.jar --cf $APP_NAME status all

cf java jstall $APP_NAME

cf java jstall $APP_NAME --args 'deadlock all'

cf java thread-dump $APP_NAME

cf java jstall $APP_NAME --args 'most-work --dumps 5 all'

cf java jstall $APP_NAME --args 'flame all'
# Downloads an HTML flamegraph to your current directory

cf java asprof-start-cpu $APP_NAME
# reproduce the slow operation or wait 30–60 s
cf java asprof-stop $APP_NAME
# Downloads $APP_NAME-asprof-<random>.jfr — open in JDK Mission Control

cf java heap-dump $APP_NAME

cf java heap-dump $APP_NAME --open
# Opens hprof-analyzer in the browser with the dump pre-loaded

hprof-analyzer $APP_NAME-heapdump-*.hprof report.html
# Open report.html → "Leak Suspects" and "Top Consumers" tabs

cf java heap-dump $APP_NAME

cf java heap-dump $APP_NAME --open
# Spins up a local server and opens hprof-analyzer in the browser automatically.
# On macOS with the Application Firewall enabled, click Allow when prompted.
# In the browsers, allow the page to access local services when prompted.

cf java heap-dump $APP_NAME --redact            # lean: zeros primitive arrays
cf java heap-dump $APP_NAME --redact-complete   # complete: zeros all primitive values

cf java heap-dump $APP_NAME --compress          # saves as .hprof.gz

cf java thread-dump $APP_NAME

cf java thread-dump $APP_NAME > thread-dump.txt

cf java jstall $APP_NAME --args 'deadlock all'

cf java asprof-start-cpu $APP_NAME
# reproduce the slow operation or wait 30–60 s
cf java asprof-stop $APP_NAME
# Downloads $APP_NAME-asprof-<random>.jfr

cf java jstall $APP_NAME --args 'flame all'

# Record everything (thread dump, heap histogram, jcmd output) into a zip:
cf java record-status $APP_NAME

# Include JFR recording and flame graph (slower, larger):
cf java record-status $APP_NAME --full

# Replay the zip locally with jstall:
jstall -f $APP_NAME-status.zip status all
jstall -f $APP_NAME-status.zip threads all

# Full status report (deadlock detection, hot threads, etc.):
cf java jstall $APP_NAME

# Run a specific jstall subcommand:
cf java jstall $APP_NAME --args 'most-work --dumps 3 all'
cf java jstall $APP_NAME --args 'flame all'

jstall --cf $APP_NAME status all

# Lean redaction — zeros primitive arrays (byte[], char[], etc.):
cf java heap-dump $APP_NAME --redact

# Complete redaction — zeros all primitive arrays and individual primitive fields:
cf java heap-dump $APP_NAME --redact-complete

# Redact and compress:
cf java heap-dump $APP_NAME --redact --compress

# Redact and open in browser:
cf java heap-dump $APP_NAME --redact --open

# Redact sensitive values and keep the dump compressed:
cf java heap-dump $APP_NAME --redact --compress

# Redact and open immediately in hprof-analyzer:
cf java heap-dump $APP_NAME --redact --open

# Use complete redaction for maximum privacy:
cf java heap-dump $APP_NAME --redact-complete --compress

cf java heap-dump $APP_NAME --open

cf java heap-dump $APP_NAME --open-url http://localhost:8080

java -jar query.jar query myrecording.jfr "gc-pauses"

SELECT
    start_time,
    duration_ms,
    cause,
    heap_used_after_mb
FROM gc_pauses
WHERE duration_ms > 200
ORDER BY duration_ms DESC

java -jar query.jar query myrecording.jfr "allocation-by-site"

SELECT
    stack_top,
    SUM(allocation_size) AS total_bytes,
    COUNT(*)             AS samples
FROM object_allocations
GROUP BY stack_top
ORDER BY total_bytes DESC
LIMIT 20

java -jar query.jar query myrecording.jfr "hot-methods"

java -jar query.jar views
java -jar query.jar macros

# Import the recording into a persistent .db file:
java -jar query.jar import myrecording.jfr mydb.db

# Query it directly with DuckDB CLI:
duckdb mydb.db "SELECT * FROM hot_methods"

# Or open DuckDB's own browser UI:
duckdb -ui mydb.db

java -jar query.jar serve gc.log
# or in the browser: drag-and-drop a .log file

java -jar query.jar serve \
  --templates-dir ~/my-jfr-templates \
  --port 4244 \
  myrecording.jfr

# 1. Start recording (replace 1234 with your JVM's PID, or use the main class name)
java -jar condensed-data.jar agent 1234 start recording.cjfr

# 2. Let it run for as long as you need, then stop
java -jar condensed-data.jar agent 1234 stop

# 3. View a summary of what was captured
java -jar condensed-data.jar summary recording.cjfr

# 4. Open an event view (e.g. GC pauses, hot methods)
java -jar condensed-data.jar view recording.cjfr gc-pauses

# Attach and start (runs until you stop it)
java -jar condensed-data.jar agent <PID> start gc-investigation.cjfr

# After the issue reproduces (minutes or hours later):
java -jar condensed-data.jar agent <PID> stop

# View GC pause trend
java -jar condensed-data.jar view gc-investigation.cjfr gc-pauses

java -jar condensed-data.jar agent <PID> start \
  --rotating --max-size=100m --max-files=5 \
  recording_$index.cjfr

java -jar condensed-data.jar agent <PID> stop
java -jar condensed-data.jar view recording_0.cjfr gc-pauses

java -jar condensed-data.jar agent <PID> start \
  --rotating --max-size=100m --max-files=3 \
  recording_$index.cjfr

java -javaagent:condensed-data.jar=start,rotating,max-size=100m,max-files=3,recording.cjfr \
  -jar myapp.jar

# Single file:
java -jar condensed-data.jar condense myrecording.jfr output.cjfr

# Whole folder or ZIP:
java -jar condensed-data.jar condense recordings/ output.cjfr

# Inflate back to JFR for tools that don't support .cjfr:
java -jar condensed-data.jar inflate output.cjfr restored.jfr

# Print a summary:
java -jar condensed-data.jar summary recording.cjfr

# Use JFR named views (gc-pauses, hot-methods, allocation-by-site, …):
java -jar condensed-data.jar view recording.cjfr gc-pauses

# Open in jfr-query notebook UI:
java -jar query.jar serve recording.cjfr
# or drag-and-drop onto https://parttimenerd.github.io/jfr-query/

# Download snapshot build from:
# https://github.com/parttimenerd/jmc/releases/tag/snapshot
# Then open JMC and File > Open > select your .cjfr file

java -jar condensed-data.jar inflate recording.cjfr recording.jfr

hprof-analyzer heap.hprof report.html

hprof-analyzer heap.hprof.gz report.html
hprof-analyzer heap.hprof.zip report.html

hprof-analyzer update nightly

hprof-analyzer heap.hprof report.html
# Open report.html → "Top Consumers" tab

hprof-analyzer heap summary heap.hprof

hprof-analyzer heap.hprof report.html
# Open report.html → "Leak Suspects" tab

hprof-analyzer heap summary heap.hprof

# First run: full analysis (5–15 min on large dumps)
hprof-analyzer heap summary heap.hprof

# All subsequent runs: ~1 s from cache
hprof-analyzer heap summary heap.hprof
hprof-analyzer heap histogram heap.hprof
hprof-analyzer heap query heap.hprof --oql "SELECT COUNT(*) FROM java.lang.String"
hprof-analyzer heap browse heap.hprof          # browse dominator tree
hprof-analyzer heap inspect heap.hprof --index 42

hprof-analyzer query heap.hprof --repl

hprof-analyzer server heap.hprof
# → open http://127.0.0.1:7070

claude mcp add hprof -- hprof-analyzer mcp

{ "mcpServers": { "hprof": { "command": "hprof-analyzer", "args": ["mcp"] } } }

# Lean mode (default): zeroes all primitive array elements (byte[], char[], int[], …)
hprof-analyzer redact heap.hprof redacted.hprof

# Complete mode: also zeroes scalar instance fields and static fields
hprof-analyzer redact --complete heap.hprof redacted.hprof

hprof-analyzer mat caches heap.hprof

hprof-analyzer redact heap.hprof redacted.hprof

import me.bechberger.HprofRedactor;
import java.nio.file.Path;

HprofRedactor.redact(
    Path.of("heap.hprof"),
    Path.of("heap-redacted.hprof")
);

import me.bechberger.jhserr.HsErrParser;
import me.bechberger.jhserr.model.HsErrReport;

HsErrReport report = HsErrParser.parse(Path.of("hs_err_pid12345.log"));
System.out.println(report.header().errorType());    // e.g. SIGSEGV
System.out.println(report.header().errorDetail());  // problematic frame
System.out.println(report.vmInfo().version());      // JVM version string

// Java frames from the crashing thread:
report.currentThread().javaFrames()
      .forEach(f -> System.out.println(f.method()));

java -jar jhserr.jar summary hs_err_pid12345.log

java -jar jhserr.jar redact hs_err_pid12345.log -o redacted.log
java -jar jhserr.jar redact --aggressive hs_err_pid12345.log -o redacted.log
java -jar jhserr.jar redact --scan hs_err_pid12345.log   # scan only, no output

java -jar jhserr.jar redact --username jdoe --sensitive-path /home/jdoe/project \
    hs_err_pid12345.log -o redacted.log

report.accept(new HsErrVisitor() {
    @Override
    public void visitJavaFrames(FrameList frames) {
        frames.frames().forEach(f -> System.out.println(f.method()));
    }
    @Override
    public void visitEnvironmentVariables(EnvironmentVariables vars) {
        vars.variables().forEach((k, v) -> System.out.println(k + "=" + v));
    }
});

String json = HsErrJson.toJson(report);
HsErrReport restored = HsErrJson.fromJson(json); // round-trip

java -jar jhserr.jar json to hs_err.log > report.json
java -jar jhserr.jar json from report.json > restored.log
java -jar jhserr.jar json schema > schema.json

mvn test          # first run — collects coverage, no reordering yet
# edit a source file, then:
mvn test          # second run — tests covering changed code run first

mvn test-order:show
# or the fully-qualified form if you haven't set up the prefix:
mvn me.bechberger:test-order-maven-plugin:show

<settings>
  <pluginGroups>
    <pluginGroup>me.bechberger</pluginGroup>
  </pluginGroups>
</settings>

mvn me.bechberger:test-order-maven-plugin:show

mvn test-order:show       # ranked list of all tests
mvn test-order:affected test  # run only tests affected by recent changes
mvn test-order:dashboard  # full HTML report

./gradlew testOrderShow
./gradlew testOrderAffected
./gradlew testOrderDashboard

mvn test-order:detect-dependencies   # Maven
./gradlew testOrderDetectDependencies  # Gradle

mvn test-order:diagnose         # Maven
./gradlew testOrderDiagnose     # Gradle

<!-- Step 1: assemble fat JAR -->
<plugin>
  <artifactId>maven-assembly-plugin</artifactId>
  <version>3.6.0</version>
  <configuration>
    <descriptorRefs><descriptorRef>jar-with-dependencies</descriptorRef></descriptorRefs>
    <archive><manifest><mainClass>com.example.App</mainClass></manifest></archive>
  </configuration>
  <executions>
    <execution>
      <id>make-assembly</id>
      <phase>package</phase>
      <goals><goal>single</goal></goals>
    </execution>
  </executions>
</plugin>

<!-- Step 2: wrap it -->
<plugin>
  <groupId>me.bechberger</groupId>
  <artifactId>execjar</artifactId>
  <version>VERSION</version>
  <executions>
    <execution>
      <goals><goal>execjar</goal></goals>
    </execution>
  </executions>
</plugin>

./target/your-app

<configuration>
  <minJavaVersion>17</minJavaVersion>
  <maxJavaVersion>21</maxJavaVersion>
</configuration>

<configuration>
  <jvmOpts>-Xmx512m -XX:+UseG1GC</jvmOpts>
  <javaProperties>
    <app.name>My Application</app.name>
    <app.config>/opt/myapp/config</app.config>
  </javaProperties>
</configuration>

EXECJAR_DEBUG=1 ./target/your-app

curl -L -o lambda-stringer.jar \
  https://github.com/parttimenerd/lambda-stringer/releases/download/latest/lambda-stringer.jar
java -javaagent:lambda-stringer.jar -jar your-app.jar

<dependency>
  <groupId>me.bechberger</groupId>
  <artifactId>lambda-stringer</artifactId>
  <version>VERSION</version>
  <scope>test</scope>
</dependency>

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-surefire-plugin</artifactId>
  <configuration>
    <argLine>-javaagent:${settings.localRepository}/me/bechberger/lambda-stringer/VERSION/lambda-stringer-VERSION.jar</argLine>
  </configuration>
</plugin>

# Compact format for log parsers
java -javaagent:lambda-stringer.jar=format=%S#%m:%l -jar your-app.jar
# → com.example.Scheduler#buildTask:42

# Simple class name only
java -Dlambda.tostring.format="%i@%s:%l" -javaagent:lambda-stringer.jar ...
# → Runnable@Scheduler:42

VirtualMachine vm = VirtualMachine.attach(pid);
vm.loadAgent("/path/to/lambda-stringer.jar");
vm.detach();

java -javaagent:target/meta-agent.jar=server -jar your-program.jar
# custom port:
java -javaagent:target/meta-agent.jar=server,port=8080 -jar your-program.jar

public class MyHandler implements InstrumentationCallback {
    @Override
    public CallbackAction onAddTransformer(ClassFileTransformer transformer) {
        System.err.println("New transformer: " + transformer.getClass().getName());
        return CallbackAction.ALLOW; // or IGNORE to suppress it
    }

    @Override
    public void onExistingTransformer(ClassFileTransformer transformer) {
        System.err.println("Existing transformer: " + transformer.getClass().getName());
    }

    @Override
    public CallbackAction onInstrumentation(ClassFileTransformer transformer,
            ClassArtifact before, ClassArtifact after) {
        System.out.println("Instrumenting: " + before.klass().getName());
        return CallbackAction.ALLOW;
    }
}

java -javaagent:target/meta-agent.jar=server,cb=com.example.MyHandler -jar your-program.jar

cd native && make
# macOS:
java -agentpath:native/native_agent.dylib \
     -javaagent:target/meta-agent.jar=server \
     -jar your-program.jar
# Linux:
java -agentpath:native/native_agent.so \
     -javaagent:target/meta-agent.jar=server \
     -jar your-program.jar

<plugin>
  <groupId>me.bechberger</groupId>
  <artifactId>meta-agent-maven-plugin</artifactId>
  <version>VERSION</version>
  <executions>
    <execution>
      <phase>validate</phase>
      <goals><goal>meta-agent</goal></goals>
    </execution>
  </executions>
  <configuration>
    <server>true</server>
    <callbackClasses>
      <callbackClass>com.example.MyHandler</callbackClass>
    </callbackClasses>
  </configuration>
</plugin>

<dependency>
  <groupId>me.bechberger</groupId>
  <artifactId>meta-agent</artifactId>
  <version>VERSION</version>
  <scope>test</scope>
</dependency>

import me.bechberger.jthreaddump.ThreadDumpParser;
import me.bechberger.jthreaddump.model.ThreadDump;

String raw = Files.readString(Path.of("dump.txt"));
ThreadDump dump = ThreadDumpParser.parse(raw);

System.out.println("Threads: " + dump.threads().size());
dump.threads().forEach(t ->
    System.out.println(t.name() + " — " + t.state()));

if (!dump.deadlockInfos().isEmpty()) {
    System.out.println("Deadlock detected!");
}

String raw = JStackUtil.captureThreadDump(pid);        // uses jstack
String raw = JStackUtil.captureThreadDump(pid, true);  // uses jcmd (Thread.print -l)
ThreadDump dump = ThreadDumpParser.parse(raw);

ThreadDump dump = ThreadDumpParser.parse(dumpText);
dump.threads().stream()
    .filter(t -> t.state() == Thread.State.BLOCKED)
    .forEach(t -> System.out.println(t.name() + " is blocked"));

dump.threads().stream()
    .filter(t -> t.cpuTimeSec() != null)
    .sorted((a, b) -> Double.compare(b.cpuTimeSec(), a.cpuTimeSec()))
    .limit(10)
    .forEach(t -> System.out.printf("%s: %.2f sec CPU%n", t.name(), t.cpuTimeSec()));

ThreadDump before = ThreadDumpParser.parse(Files.readString(Path.of("before.txt")));
ThreadDump after  = ThreadDumpParser.parse(Files.readString(Path.of("after.txt")));
System.out.println("Thread delta: " + (after.threads().size() - before.threads().size()));

jthreaddump dump.txt           # parse and display summary
jstack <pid> | jthreaddump -   # pipe from jstack
jthreaddump dump.txt -v        # verbose output