Monitoring Memory Usage In Wildfly: A Comprehensive Guide

JBoss, now known as WildFly, is a platform for implementing and deploying Java applications and services. It is important to monitor the memory usage of your WildFly server to ensure optimal performance and avoid issues such as OutOfMemory errors. There are several tools and methods available to monitor memory usage in WildFly, including the use of the JMX console, the CLI command, JConsole, and third-party monitoring solutions. By monitoring memory usage, administrators can identify and troubleshoot any potential memory-related issues and ensure the smooth operation of their WildFly applications.

Using the CLI command

To monitor memory usage in JBoss WildFly, you can use the CLI command. Here's a step-by-step guide on how to do it:

Firstly, connect to your JBoss WildFly instance using the CLI command. You can do this by opening a terminal and navigating to the directory where your JBoss CLI script is located. The default location for the script is `$JBOSS_HOME/bin`. Once you're in the correct directory, you can run the following command:

/jboss-cli.sh -c --controller=localhost:9999

Make sure to replace `localhost:9999` with the appropriate host and port for your JBoss WildFly instance.

Once you're connected, you can use the following command to get the JVM memory details:

/core-service=platform-mbean/type=memory/:read-resource(recursive=true,proxies=true,include-runtime=true,include-defaults=true)

This command will provide you with detailed information about the memory usage in your JBoss WildFly instance.

Additionally, you can also use the CLI command to monitor the memory usage over time. For example, you can use the following command:

/core-service=platform-mbean/type=memory:read-resource(include-runtime=true)

This command will give you real-time updates on the memory usage, including details such as the initial memory allocation, used memory, committed memory, and the maximum memory usage.

By monitoring the memory usage in JBoss WildFly, you can ensure that your application is running optimally and identify any potential memory-related issues. It's important to regularly check memory usage and set up alerts to notify you if the memory usage crosses certain thresholds. This proactive approach will help you maintain the performance and stability of your JBoss WildFly applications.

Using the JConsole tool

JConsole is a tool that can be used to monitor memory usage in JBoss WildFly. It is bundled with the JRE and provides a preconfigured wrapper script for JBoss EAP. This tool allows you to monitor basic JVM processes, including memory usage, thread utilisation, loaded classes, and other JVM metrics.

To use JConsole, no configuration is necessary if you are running it locally on the same machine as JBoss EAP. However, if you are monitoring JBoss EAP on a remote machine, you will need to configure JBoss EAP to accept remote JMX connections. This involves creating a management user, binding the management interface to the IP address you will use for monitoring, and using the provided URI with your management user name and password in JConsole to connect to the JBoss EAP server.

Connecting to a Local JBoss EAP JVM Using JConsole:

• Run the jconsole script in EAP_HOME/bin.
• Under Local Process, select the JBoss EAP JVM process you want to monitor. For a standalone JBoss EAP server, there will be only one JVM process.

Connecting to a Remote JBoss EAP JVM Using JConsole:

• Configure JBoss EAP for remote monitoring connections as mentioned above.
• Download and extract a ZIP installation of JBoss EAP to your local machine.
• Run the jconsole script in EAP_HOME/bin.
• Under Remote Process, insert the URI for the remote JBoss EAP JVM process you want to monitor, along with the user name and password for the monitoring connection.

By following these steps, you can effectively use JConsole to monitor memory usage and other important metrics in JBoss WildFly.

Monitoring heap and non-heap memory usage

Monitoring memory usage in JBoss WildFly can be done through various tools and methods. One way is to use the JBoss CLI (Command Line Interface) by executing the following command:

> ./jboss-cli.sh -c --controller=localhost:9999

Once connected, you can retrieve detailed information about the JVM memory by using the following command:

> /core-service=platform-mbean/type=memory/:read-resource(recursive=true,proxies=true,include-runtime=true,include-defaults=true)

This command will provide insights into both heap and non-heap memory usage. The output will include details such as the initial memory allocation, used memory, committed memory, and the maximum memory limit for both the heap and non-heap memory areas.

Alternatively, you can utilise the JBoss management console, which provides a graphical user interface for monitoring memory usage. Simply navigate to the "System status" section and select "JVM" to view memory-related metrics.

Another tool at your disposal is JConsole, which is bundled with the JRE. JConsole offers a visual representation of memory usage, allowing you to monitor both heap and non-heap memory consumption over time.

Additionally, there are dedicated check plugins available, such as the "wildfly-memory-usage" plugin, which can monitor both heap and non-heap memory usage via the HTTP-JSON based API (JBossAS REST Management API). This plugin eliminates the need for additional configurations or deployments, providing a straightforward way to monitor memory usage in both standalone and domain modes.

It's important to note that memory usage can vary depending on the tool used for monitoring. For example, the Linux "top" command may display different memory usage statistics compared to Java-specific tools. This discrepancy can be attributed to off-heap memory allocation or other memory management techniques employed by the application server.

Troubleshooting memory leaks

Understanding Memory Leaks

It is important to comprehend the concept of memory leaks and their causes. Memory leaks happen when an application does not properly manage memory, holding onto memory that is no longer needed. This can be due to various factors, such as unclosed connections, improper variable usage, or inefficient caching strategies.

Tools for Detection

Java provides several tools to help detect memory leaks, including:

• Jmap: A command-line tool for generating heap dumps of Java applications.
• Jhat: A command-line tool used to analyze heap dumps.
• VisualVM: A visual tool for monitoring and profiling Java applications.
• Java Mission Control: Another visual tool for monitoring and profiling.

Finding Memory Leaks in WildFly

To specifically address memory leaks in WildFly, follow these steps:

Start WildFly with specific JVM options:

XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/path/to/heapdump

• Reproduce the OutOfMemoryError to generate a heap dump.
• Analyze the heap dump using tools like jhat or VisualVM to identify memory consumption patterns.
• Identify the classes or objects consuming excessive memory.
• Trace the object graph to pinpoint the root cause of the memory leak.

Common Causes and Prevention

Some common causes of memory leaks in WildFly include:

• Unclosed database, JMS connections, and servlet streams.
• Static and thread-local variables holding large objects.
• Ineffective caching strategies for large objects.

To prevent memory leaks, follow these best practices:

• Ensure all connections and streams are properly closed.
• Avoid using static or thread-local variables for large objects.
• Implement efficient caching strategies to manage large objects.
• Regularly monitor memory usage and restart WildFly to release accumulated memory.

Example Scenarios

• In WildFly 10, a memory leak was identified due to a bug in the Undertow subsystem, which required replacing the Undertow modules with the latest stable release versions.
• In another case, a memory leak was caused by thousands of instances of oracle.jdbc.driver.T4CPreparedStatement being kept in memory. The issue was resolved by investigating the prepared statement cache and addressing the duplication.

Tracking memory statistics

Command-Line Interface (CLI)

You can use the CLI command to monitor memory usage in WildFly. Connect to your WildFly server using the CLI command:

/jboss-cli.sh -c --controller=localhost:9999

Then, you can get the JVM memory details by executing the following command:

/core-service=platform-mbean/type=memory/:read-resource(recursive=true,proxies=true,include-runtime=true,include-defaults=true)

This command will provide detailed information about the memory usage, including the heap and non-heap memory statistics.

JBoss Management Console

The JBoss Management Console provides a graphical user interface to monitor your WildFly server. To access it, log in to the WildFly console and select "JVM" from the "System Status" menu. This will display various memory statistics, such as heap memory usage, non-heap memory usage, and garbage collection details.

JConsole

JConsole is a Java Monitoring and Management Console that comes bundled with the JRE. It allows you to monitor memory usage and other JVM statistics. To use JConsole, you need to enable JMX remote connections in your WildFly configuration file and then connect to your WildFly server using JConsole.

Check Plugin

There is a check plugin available that monitors the heap and non-heap memory usage of a WildFly server using its HTTP-JSON based API (JBossAS REST Management API). This plugin supports both standalone and domain modes. It provides detailed memory statistics, including heap and non-heap memory usage, committed memory, and maximum memory.

SolarWinds Server & Application Monitor

SolarWinds SAM provides a JBoss performance monitoring template that allows you to track various memory statistics, such as used and committed memory, memory pool statistics, free memory, total memory, garbage collection details, and more. It also offers alerting capabilities to notify you when critical thresholds are crossed.

Frequently asked questions