Eclipse Jifa is an open-source project for troubleshooting Java applications. Comparable solutions often run on the client, where Jifa provides a scalable, web-based solution to prevent local memory and resource challenges. Currently, Heap Dump Analysis and GC Log Analysis are supported with features such as target heap overview, leak suspects, thread information and GC root analysis.
Vue 2.0 and Vert.x are used for the frontend and backend, respectively. The Master-Worker pattern is used which consists of one or more Master(s) that route requests from the browser to the managed set of workers who perform the analysis. Based on the load, the Master(s) schedule extra Workers.
There are several ways to deploy Eclipse Jifa: only one worker, one master and several workers or the Kubernetes model. The Kubernetes scheduling solution uses the Kubernetes Java Client to create extra pods on demand based on the resource usage.
The analytic engine currently has two parts: the Heap Dump Analysis service based on Eclipse Memory Analyzer (MAT) and the GC Log Analysis service which supports the G1, Parallel GC, Serial GC, CMS and ZGC garbage collection algorithms. The GC Log Analysis Service can process logs from Java 8 and 11, while support for Java 17 is under development.
The online demo environment may be used to evaluate Eclipse Jifa, or alternatively, a Docker image may be used to quickly run Eclipse Jifa:
docker run -p 8102:8102 jifadocker/jifa-worker:demo
The starting page is displayed after browsing to http://localhost:8102:
After clicking on Add Heap Dump File, various options are presented to supply the heap dump file. The application expects a .hprof file which contains the heap dump of a Java application. The jcmd command supplied by the JDK is one of the options to create the heap dump:
jcmd [pid] GC.heap_dump [location to store the hprof file]
After adding the heap dump, it’s displayed on the page and clicking on analyze starts the analysis.
After the analysis is finished, an overview of the results is displayed. Clicking the blue part of the ring displays the following overview:
There are various Views available in Eclipse Jifa to further analyze the heapdump. The Dominator Tree shows that a large percentage of the heap comes from a Thread, when drilling down the School object, an ArrayList and a lot of long String objects are displayed. That’s because the heap dump is created from a demo application that stores random long String objects in an ArrayList located in a School object.
Eclipse Jifa’s heap dump analysis, based on Eclipse MAT, provides detailed documentation about analyzing heap dumps.
The second feature of Eclipse Jifa is garbage collection log analysis. After clicking on GC Log Analysis and then Add GC Log File, various options are presented to supply the garbage collection log file. The following command is one of the options to create a garbage collection log:
java -Xlog:gc*=debug:file=[log file location] -jar [jar location]
After supplying the log file and completing the analysis, an overview is shown:
The different tabs provide more detailed information, starting with the Graphs tab which displays statistics such as garbage collection count, pause times and the heap size:
The GC Cause And Phase displays the garbage collection causes and more detailed information on the duration of the pauses:
The latest tab GC Detail provides all the details, where the rows display the following information:
Alibaba Cloud, Netflix and other members of the open-source community are contributing to Eclipse Jifa, currently in the incubation phase and released as version 0.1. The team is working on graduating the project to the Mature phase.
Sanhong Li, Java Champion and co-leader of the GreenTea JUG, and Denghui Dong, OpenJDK committer, both from Alibaba Cloud, provided more insights into the Eclipse Jifa project during their session at the 2022 jChampions Conference.