GlassFish Monitoring: A Complete Guide

GlassFish is an open-source application server used to deploy and run Jakarta EE applications. Jakarta EE applications are enterprise applications built on the Jakarta EE platform. They are designed to have production-grade scalability, reliability, and security.

As GlassFish is the foundation for Jakarta EE apps, monitoring its performance is essential to ensure optimal application performance and availability. In this article, we share a comprehensive guide to monitoring key GlassFish metrics using native tools.

By effectively tracking these metrics, you can optimize your GlassFish environment to eliminate bottlenecks and improve resilience.

What is GlassFish?

GlassFish is a web server implementation that supports all Jakarta EE specifications, including Jakarta CDI, Jakarta Transactions, Jakarta Messaging, Jakarta REST, and Jakarta Security.

GlassFish was originally developed by Sun Microsystems in 2005. It was based on the J2EE platform — the predecessor to the Jakarta EE platform. In 2010, Sun Microsystems was acquired by Oracle, and GlassFish became an Oracle product. In 2018, it was transferred to the Eclipse Foundation, where it is now developed and maintained.

GlassFish is a great choice for running and serving a wide range of Java-based applications, including web applications, web services, e-commerce applications, and enterprise applications. Its built-in scalability makes it suitable for both small-scale projects and enterprise deployments.

Architecture

GlassFish has a modular architecture, which means that it’s made up of different Jakarta EE components, each providing a unique set of features. While installing GlassFish, developers can choose which components to include based on what they need. They can also implement custom functionality through add-on components.

This modular architecture brings multiple benefits, including flexibility, efficient memory usage, and low startup times. The core of GlassFish is built on a lightweight and performant Java Virtual Machine (JVM) that executes the Java bytecode of deployed applications.

GlassFish vs. Tomcat and Jetty

GlassFish, Tomcat, and Jetty are all open-source web servers that can be used to host Java applications. However, GlassFish is different in some key ways:

• GlassFish is a fully featured application server, while Tomcat and Jetty are more lightweight web servers that support only a subset of the Jakarta EE specifications.
• GlassFish is more complex to configure and manage than Tomcat and Jetty because it has more features and configuration options.
• GlassFish is a good fit for deploying enterprise applications, while Tomcat and Jetty are better suited for hosting smaller, simpler applications.

Why is it important to monitor GlassFish?

Monitoring GlassFish is important for the following reasons:

Ensuring high performance

GlassFish is a crucial part of many IT infrastructures, as it houses the applications that users rely on. Regular monitoring of GlassFish ensures that these applications always perform at their best. By tracking metrics like response time, throughput, number of errors, and memory utilization, you can identify any dips in performance and take corrective action.

For example, if you notice that a spike in memory utilization is coinciding with an increase in average response time, you can surmise that a potential memory leak is slowing the server down.

Removing bottlenecks and maximizing throughput

Bottlenecks can severely impact application performance and user satisfaction. They can occur anywhere in the system, from the application code to the underlying hardware. For instance, poorly designed application code can lead to a bottleneck, but continuous monitoring of the GlassFish server enables you to detect and resolve bottlenecks early.

For example, an administrator may detect that an application is stuck while processing a request for a long time. By checking the logs and database metrics, they may find out that the application is waiting for a database query to execute. Armed with these insights, the administrator will be able to quickly identify and fix the problem.

Ensuring high availability

GlassFish is a resilient application server but it still requires regular monitoring to keep deployed applications up and running. By tracking metrics like uptime, HTTP response codes, and resource utilization, administrators can detect potential issues early on and implement failover mechanisms to maintain business continuity.

For example, a monitoring system may generate an alarm if an instance approaches 90% memory utilization. This will prompt an administrator to investigate the issue before the instance crashes, leading to service disruption.

Optimizing configurations

As applications evolve and usage patterns change, it becomes important to optimize configurations for continued performance. Monitoring GlassFish provides administrators with real-time insights regarding performance, which can be used to fine-tune configuration parameters.

For example, an administrator may notice that an instance slows down during peak hours. This may prompt them to consider adjusting settings related to the thread pool, connection pool, or caching.

Facilitating faster issue resolution

Monitoring GlassFish can also lead to faster troubleshooting. If a problem occurs, administrators can use real-time monitoring data to contextualize the issue and search for the root cause. This reduces the mean time to resolution (MTTR) and enhances the reliability of the overall system.

For example, if the GlassFish server experiences a sudden spike in CPU usage, administrators can identify the anomaly from the monitoring dashboards. They can then analyze different metrics, like concurrent requests, ongoing transactions, and active threads, to quickly pinpoint the issue and fix it.

Enhancing security and mitigating vulnerabilities

Web applications are susceptible to security threats and vulnerabilities. By tracking metrics such as login attempts, access denied errors and memory leaks, you can protect your applications and sensitive data from potential breaches.

For example, if you see multiple access denied errors, you can check the application logs to see if someone is trying to log in with elevated privileges.

Key metrics to monitor GlassFish performance

GlassFish exposes several metrics that can be used to track its performance and availability in real time. Let's explore the key metric categories.

Application metrics

Application metrics measure the health and performance of Java applications deployed inside a GlassFish instance. They can assist in identifying bottlenecks, troubleshooting application-level problems, and optimizing performance. Here are a few examples:

HTTP metrics

HTTP metrics enable GlassFish administrators to ensure that HTTP requests are being processed efficiently. Here are some key HTTP metrics to remember:

JVM metrics

JVM metrics can help administrators detect memory leaks, optimize garbage collection settings, and ensure efficient resource utilization. This leads to a stable and high-performing GlassFish environment for hosting Java EE applications. Let’s look at a few examples:

Transaction metrics

Monitoring transaction service metrics is vital for ensuring data integrity and consistency in web applications. Here are a few important transaction metrics to monitor:

Server metrics

Server metrics provide statistics on the GlassFish core, application clients, and resource utilization. They paint a good overall picture of the server's current status and well-being. The most important server metrics to focus on are:

Tools for monitoring GlassFish performance

Now that we have explored some key performance metrics of GlassFish, let’s look at a few ways to measure and track them.

Using the asadmin command line utility

GlassFish ships with a command-line utility, asadmin, that can be used to gather key performance metrics in real time. By issuing commands via the utility, you can display several statistics, including requests per second, throughput, JVM memory utilization, thread pool usage, JMS service stats, and connector service statistics.

For example, to view a list of monitorable objects related to the GlassFish server, you can run the following command:

asadmin> list --monitor "server.*" 

The output should show the following objects:

server.applications 
server.http-service 
server.jvm 
server.resources  
server.jms-service 
server.network  
server.orb 
server.connector-service 
server.web  
server.thread-pool 
server.security 
server.transaction-service 

You can then drill down on the relevant object to retrieve the desired metrics. For example, to fetch the max request processing time for an application named sample, you can use the following identifier in the asadmin monitor command.

server.applications.sample.server.request.maxtime 

Using the administration console

GlassFish also has a web-based administration console that can be used to manage and monitor a server. By default, the console is available at http://localhost:4848, and requires a login.

The console offers several built-in features, including:

• Adding or connecting to brokers and clients
• Configuring, managing, and monitoring connection services
• Viewing and managing physical destinations
• Monitoring messaging services
• Monitoring broker operations

Using the Site24x7 monitoring engine

Site24x7's monitoring engine allows you to monitor GlassFish performance in real time. Among other things, you can analyze JVM performance, keep tabs on transactions, and gauge the overall HTTP success rate of your web applications. Here are some of the key monitorable metrics it offers:

• CPU usage
• JVM runtime memory usage
• Thread counts
• JIT compiler usage
• Background and web transactions
• Top error codes

Conclusion

Monitoring GlassFish is essential for ensuring optimal application performance, high availability, and robust security. By tracking key metrics using native tools and Site24x7, administrators can proactively manage and optimize their GlassFish environment, creating a resilient platform for Jakarta EE applications.