Full stack Tomcat performance monitoring

Apache Tomcat is an open-source web server and servlet container that implements the Java Servlet, Java Server Pages (JSP), and WebSocket technologies. It is widely used to deploy Java-based web applications.

The key components of the Tomcat architecture include:

• Catalina: The servlet container that hosts servlets and JSPs, manages their lifecycle, and handles request processing.
• Coyote: The connector that enables communication between Tomcat and the web server using various protocols such as HTTP, AJP (Apache JServ Protocol), and others.
• Jasper: The JSP engine that compiles JSPs into Java servlets for execution.
• Service: Within the Catalina server, there can be one or more service elements. Each service element groups one or more connector components together with a single engine. Connectors listen for requests on TCP ports and send them to the service's engine for processing.
• Cluster: The component that enables clustering and load balancing of multiple Tomcat instances for high availability and scalability.

Monitoring Apache Tomcat is essential to ensure the optimal performance and availability of Java web applications. By monitoring Tomcat, IT teams can detect and resolve performance issues, identify potential bottlenecks, ensure resource utilization is within limits, and maintain high availability and user satisfaction.

Monitoring of Apache Tomcat should be done at different levels:

• The Java Virtual Machine (JVM) used to host Apache Tomcat must be monitored for resource utilization, memory usage, garbage collection activity, thread deadlocks and overall health of the JVM.
• The Apache Tomcat application server’s performance must be monitored to identify any performance bottlenecks such as worker thread utilization, connection pool usage, and other server-level metrics.
• Log files of the application server must be tracked to monitor information about errors, warnings, requests, and other events.
• Code-level profiling using byte-code instrumentation to measure the performance of individual Java methods.
• Application transactions can be traced across JVMs using byte-code instrumentation to trace the flow of requests across different components and measure performance metrics such as response times, database queries, and external API calls to detect application bottlenecks. Tracing application transactions using byte-code instrumentation can help identify application bottlenecks and performance issues.

By monitoring at all these levels, you will have the best chance of diagnosing performance issues quickly, when users complain that “the Java application is slow”.

IT operations, Site Reliability Engineers (SREs) and DevOps teams can benefit from Apache Tomcat monitoring. They can get real-time alerts on performance issues, automated root cause analysis, deep visibility to quickly diagnose where the problems lie: is it the JVM, or the Tomcat container, the workload, the database, or an issue in the application code or its external dependencies?

Common performance issues you may encounter when supporting Apache Tomcat include high CPU usage, memory leaks, thread contention, slow request processing, database connectivity issues, and application errors. eG Enterprise monitors these performance metrics in real-time, provides historical trends, and offers automated diagnostics to troubleshoot and resolve such issues proactively.

Firstly, full stack monitoring is required. This includes monitoring the JVM, the Tomcat container, server logs and application transactions. Metrics from these different sources must be aggregated and presented in easy-to-understand visual dashboards. At the same time, detailed drilldowns must be provided. For example, if Tomcat’s CPU usage is high, you will need to be able to quickly drill down and see which thread in the JVM is causing the CPU spike. Historical reporting to be able to trace back in time is another key requirement.

Check out our blog on the top 7 metrics to monitor for Apache Tomcat: https://www.eginnovations.com/blog/tomcat-monitoring-metrics/

Monitoring a Tomcat web application server can provide insights that can be used to tune an Apache Tomcat web application server. For example, if the Java heap size is set too low, increase the Xmx value used for Tomcat’s JVM. There are also configuration settings that can be tuned to increase performance. Read our blog on this topic: https://www.eginnovations.com/blog/tomcat-performance-tuning/

Yes, there are differences as outlined below:

• In a microservices environment running on containers orchestrated by Kubernetes, the monitoring agent can be deployed via two options – 1) Deploy the monitoring agent as a sidecar container alongside the actual application in the same Kubernetes pod 2) Deploy a shared monitoring agent on each Kubernetes worker node that receives performance insights telemetry from all pods on that worker node.
• In a virtual environment, agent deployment on the virtual machine to monitor all Tomcat instances running on that VM is the best approach.
• In a cloud deployment, if Tomcat is deployed on a VM (such as AWS EC2 or Azure VM), agent-based monitoring is recommended. In a PaaS model, the monitoring will need to be configured in an agentless manner.