Argus gives you two tools for JVM diagnostics:

• Argus CLI — 50 diagnostic commands that work on any running JVM. No agent, no restart, no configuration. Point at a PID and get answers in seconds.
• Argus Agent — Attach as a Java agent and get a live web dashboard with GC timelines, CPU graphs, heap usage, flame graphs, and thread analysis, all streaming in real time.

Why Argus?

Every Java developer has been there. Your application is running in production, and something is wrong. Response times are climbing. Memory usage is creeping up. The GC is pausing more often than it should. You know something is happening inside the JVM, but you can't see it.

Traditional monitoring tools tell you that your app is slow, but they don't tell you why. APM solutions are expensive and heavy. JMX is clunky. JFR dumps require post-processing. By the time you've gathered the data, the incident is over.

Argus was built to solve this problem.

Installation

One command. Takes about 10 seconds.

curl -fsSL https://raw.githubusercontent.com/rlaope/argus/master/install.sh | bash

This downloads the Argus CLI to ~/.argus/ and adds it to your PATH. After installation, type argus with no arguments to see all available commands.

CLI Commands

The CLI is a standalone tool that works on any running JVM process. You don't need to have started the application with any special flags. You don't need to install an agent. If you can see the process in jps, Argus can diagnose it.

Your First Diagnosis

Let's say you have a Java application that's behaving strangely. Here's how you'd investigate:

# Step 1: Find your application's PID
argus ps

# Step 2: Get an overview of the JVM
argus info 12345

# Step 3: Check GC behavior — is the GC working too hard?
argus gc 12345

# Step 4: Look at memory — is something leaking?
argus heap 12345

# Step 5: Check threads — are there too many? Any deadlocked?
argus threads 12345
argus deadlock 12345

# Step 6: If memory is the issue, find what's consuming it
argus histo 12345

Argus CLI in action — diagnosing a running JVM process

All 50 Commands

Every command follows the same pattern: argus <command> <pid>. All commands support --format=json for scripting and --source=auto|agent|jdk to control the data source.

Dashboard

While the CLI is great for quick checks, sometimes you need to watch what's happening over time. That's where the Argus Agent comes in. Attach it to your JVM, and you get a real-time web dashboard that shows you everything.

Starting the Dashboard

Add the -javaagent flag when starting your application:

java -javaagent:argus-agent.jar \
  -Dargus.gc.enabled=true \
  -Dargus.cpu.enabled=true \
  -Dargus.allocation.enabled=true \
  -jar your-application.jar

Open http://localhost:9202/ in your browser and you'll see the dashboard immediately. No configuration files, no external services, no database.

Argus Dashboard — real-time JVM monitoring with GC, CPU, memory, and thread analysis

What the Dashboard Shows

The dashboard is organized in a JVM-health-first layout. When you're responding to an incident, you look at the most critical metrics first:

Interactive Console

The dashboard includes an interactive console at /console.html where you can run diagnostic commands directly in the browser. Click a command button, watch the typing animation, and see the results — all without leaving the dashboard.

Configuration Options

Spring Boot Integration

If you're building a Spring Boot application (3.2+), you don't need to use the -javaagent flag at all. Just add a single dependency and Argus starts automatically with your application.

Setup

// build.gradle.kts
implementation("io.argus:argus-spring-boot-starter:0.8.0")

When your Spring Boot application starts, Argus will:

• Start the JFR streaming engine automatically
• Launch the dashboard on port 9202
• Register with Spring Boot Actuator at /actuator/health/argus
• Export ~25 Micrometer metrics to your configured backend (Prometheus, Datadog, etc.)

Configuration via application.yml

argus:
  buffer-size: 131072
  server:
    port: 9202
  gc:
    enabled: true
  cpu:
    enabled: true
    interval-ms: 500
  allocation:
    enabled: true
    threshold: 524288

All properties have IDE autocomplete support. The defaults match the standard agent configuration.

Micrometer Metrics

When Micrometer is on the classpath (it is in most Spring Boot apps), Argus automatically registers ~25 JVM diagnostic metrics:

# Example Prometheus queries
argus_heap_used_bytes                    # Current heap usage
argus_gc_pause_time_max_seconds          # Worst GC pause
argus_cpu_jvm_user_ratio * 100           # JVM CPU %
argus_virtual_threads_active             # Active virtual threads
argus_allocation_rate_bytes_per_second   # Allocation pressure

Java Version Compatibility

Argus adapts its capabilities based on the Java version at runtime. You don't need to configure anything — it detects the version automatically and enables what's available.

Architecture

Argus is organized into seven modules, each with a clear responsibility:

The agent and server communicate through lock-free ring buffers in shared memory — there is no network protocol between them. This means zero serialization overhead and minimal latency from event capture to dashboard display.

Configuration Reference

All Argus properties can be set as JVM system properties (-Dargus.xxx=value) when using the agent, or in application.yml / application.properties when using the Spring Boot starter.

Agent Properties

CLI Flags