Remote Monitoring with VisualVM and JMX

DbSchema is a super-flexible database designer, which can take you from designing the DB with your team all the way to safely deploying the schema.

The way it does all of that is by using a design model, a database-independent image of the schema, which can be shared in a team using GIT and compared or deployed on to any database.

And, of course, it can be heavily visual, allowing you to interact with the database using diagrams, visually compose queries, explore the data, generate random data, import data or build HTML5 database reports.

>> Take a look at DBSchema

Slow MySQL query performance is all too common. Of course it is. A good way to go is, naturally, a dedicated profiler that actually understands the ins and outs of MySQL.

The Jet Profiler was built for MySQL only, so it can do things like real-time query performance, focus on most used tables or most frequent queries, quickly identify performance issues and basically help you optimize your queries.

Critically, it has very minimal impact on your server's performance, with most of the profiling work done separately - so it needs no server changes, agents or separate services.

Basically, you install the desktop application, connect to your MySQL server, hit the record button, and you'll have results within minutes:

>> Try out the Profiler

Repeatedly, code that works in dev breaks down in production. Java performance issues are difficult to track down or predict.

Simply put, Digma provides immediate code feedback. As an IDE plugin, it identifies issues with your code as it is currently running in test and prod.

The feedback is available from the minute you are writing it.

Imagine being alerted to any regression or code smell as you're running and debugging locally. Also, identifying weak spots that need attending to, based on integration testing results.

>> Enable code feedback in your IDE.

Of course, Digma is free for developers.

We rely on other people’s code in our own work. Every day.

It might be the language you’re writing in, the framework you’re building on, or some esoteric piece of software that does one thing so well you never found the need to implement it yourself.

The problem is, of course, when things fall apart in production - debugging the implementation of a 3rd party library you have no intimate knowledge of is, to say the least, tricky.

Lightrun is a new kind of debugger.

It's one geared specifically towards real-life production environments. Using Lightrun, you can drill down into running applications, including 3rd party dependencies, with real-time logs, snapshots, and metrics.

Learn more in this quick, 5-minute Lightrun tutorial:

>> The Essential List of Spring Boot Annotations and Their Use Cases

1. Introduction

In this article, we’ll learn how to use VisualVM and Java Management Extensions (JMX) for remote monitoring of Java applications.

2. JMX

JMX is a standard API for the management and monitoring of JVM applications. The JVM has built-in instrumentation that JMX can use for this purpose. As a result, we usually call these utilities “out-of-the-box management tools” or, in this case, “JMX agents”.

3. VisualVM

VisualVM is a visual tool that provides lightweight profiling capabilities for the JVM. There are plenty of other mainstream profiling tools. However, VisualVM is free and comes bundled with the JDK 6U7 release until early updates of JDK 8. For other versions, Java VisualVM is available as a standalone application.

VisualVM allows us to connect to both local and remote JVM applications for monitoring purposes.

When launched on any machine, it auto-discovers and starts monitoring all JVM applications running locally. However, we need to connect remote applications explicitly.

3.1. JVM Connection Modes

The JVM exposes itself for monitoring through tools such as jstatd or JMX. These tools, in turn, provide APIs for tools such as VisualVM to get profiling data.

The jstatd program is a daemon that’s bundled with the JDK. However, it has limited capability. For instance, we can’t monitor CPU usage, nor can we take thread dumps.

On the other hand, JMX technology doesn’t require any daemon to run on the JVM. Moreover, it can be used to profile both local and remote JVM applications. However, we do need to start the JVM with special properties to enable the out-of-the-box monitoring features. In this article, we’ll only focus on the JMX mode.

3.2. Launching

As we saw earlier, our JDK version can either come bundled with VisualVM or not. In either case, we can launch it by executing the appropriate binary:

./jvisualvm

If the binary is present in the $JAVA_HOME/bin folder, then the above command will open the VisualVM interface, and it could be in a different folder if installed separately.

VisualVM will launch and load all the Java applications running locally by default:

3.3. Features

VisualVM provides several useful features:

Display of local and remote Java application processes
Monitoring process performance in terms of CPU usage, GC activity, number of loaded classes, and other metrics
Visualizing threads in all processes and the times they spend in different states such as sleeping and waiting
Taking and displaying thread dumps for immediate insights into what is going on in the processes being monitored

The VisualVM features page has a more comprehensive list of available features. Like all well-designed software, VisualVM can be extended to access more advanced and unique features by installing third-party plugins available on the Plugins tab.

4. Remote Monitoring

In this section, we’ll demonstrate how to monitor a Java application using VisualVM and JMX remotely. We’ll also get a chance to explore all the necessary configurations and JVM startup options.

4.1. Application Configuration

We launch most, if not all, Java applications with a startup script. In this script, the start command usually passes essential parameters to the JVM to specify the application’s needs, such as maximum and minimum memory requirements.

Assuming we have an application packaged as MyApp.jar, let’s see an example startup command that includes the main JMX configuration parameters:

java -Dcom.sun.management.jmxremote.port=8080 
-Dcom.sun.management.jmxremote.ssl=false 
-Dcom.sun.management.jmxremote.authenticate=false 
-Xms1024m -Xmx1024m -jar MyApp.jar

In the command above, MyApp.jar is launched with out-of-the-box monitoring capability configured via port 8080. Furthermore, we deactivated SSL encryption and password authentication for simplicity.

In a production setting, we should, ideally, secure communication between VisualVM and the JVM application when in a public network.

4.2. VisualVM Configuration

Now that we have VisualVM running locally and our MyApp.jar running on a remote server, we can begin our remote monitoring session.

Right-click on the left panel and select Add JMX Connection:

Input the host:port combination in the Connection field in the resulting dialog box and click OK.

If successful, we should now be able to see a monitoring window by double-clicking the new connection from the left panel:

5. Conclusion

In this article, we’ve explored remote monitoring of Java applications with VisualVM and JMX.

Remote Monitoring with VisualVM and JMX

**Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:**

1. Introduction

2. JMX