ej-technologies blog tools and more

Since version 13, JProfiler supports profiling on Kubernetes clusters with no extra configuration.

JProfiler 13.0.6 added an important improvement for profiling a JVM in Kubernetes clusters where authentication is set up in such a way that the authentication plugin prints instructions on stdout.

For example, when the Azure Kubernetes Service (AKS) is configured to authenticate with Active Directory (AD), users will be required to authenticate their identity using the kubelogin authentication plugin. The plugin will initiate a multi-factor authentication (MFA) process by prompting the user to open a URL and enter a one-time code. Previously, the information was not visible when JProfiler was making a connection to a Kubernetes cluster.

Since JProfiler 13.0.6, the progress dialog will be expanded if such output is detected. The command line output is then shown in a text area where text can be copied to the clipboard and links can be opened directly the system web browser:

After completing the instructions, the connection will be made and the pods in the cluster will be listed.

This screencast showcases JProfiler’s support for JEE and Spring, in particular the JEE/Spring component detection and the JEE/Spring aggregation level in the call tree and hot spot views.

https://youtu.be/IEs85B8eIlY

This screencast shows how you can profile JVMs running in Kubernetes cluster with JProfiler. A profiling session with a note taking demo application sessions is started from the IDE, which provides additional benefits, like source code navigation and the automatic detection of profiled packages. Also, a standalone session is started, where an additional SSH connection is required to reach the kubectl command that can connect to the cluster.

https://youtu.be/SkbpGan-W4Q

This screencast shows how to use JProfiler to profile a JVM that is running in a Docker container. JProfiler has dedicated zero-configuration support for attaching to local and remote Docker containers and both cases are shown in the screencast.

https://youtu.be/c4lMP2h5ezI

This screencast shows how to use the sunburst diagram in the biggest objects view of JProfiler’s heap walker to visualize memory consumption of your Java application.

The sunburst diagrams shows a ring with the biggest objects and multiple reference levels of dominated objects in successive outer rings. See the documentation to read about the dominator analysis and the biggest objects view.

In the screencast, a memory snapshot of the eclipse IDE is analyzed and the class loader and classes groupings of the biggest object view are shown.

https://youtu.be/kbL-GTHD1ik

Flame graphs are a great way to get an overview of the entire call tree and to visualize performance characteristics. This screen cast shows how the jclasslib bytecode viewer is profiled. A class file is opened and the parsing of the class file is analyzed with the flame graph.

https://youtu.be/2a0vF404xgA

JProfiler’s support for Netty covers many modern web frameworks that use Netty under hood, like Vert.x, Micronaut, Ktor or Spring WebFlux.

This screen cast shows how to profile a Netty server with customized URL splitting and gives an overview of the HTTP server probe.

https://youtu.be/eXSl_LS-_Cc

This screencast shows how to use the “Inline async executions” call tree analysis to get a unified call tree across thread boundaries

This is made possible by JProfiler “request tracking” feature. In the screencast, a simple example with Spring WebFlux is profiled that creates permutations of a specified word.

Most reactive stream frameworks use the executor service JDK API for asynchronous execution. JProfiler can track tasks that are submitted to an executor service and stitch them back into a single call tree when the “Inline async executions” call tree analysis is invoked. This is essential when analyzing performance bottlenecks in asynchronous programming models.

https://youtu.be/NYPzjbuUmlI

This screen cast shows how to profile HTTP calls with the HTTP client probe and use the HTTP remote request tracking feature to follow HTTP calls from one JVM into another.

A simple Spring Boot project with two application is profiled: A gateway server that serves static files and proxies API request to a second server that handles REST calls.

You can see how JProfiler tracks calls from the browser including the JavaScript stack trace through the gateway server into the REST server. The HTTP client probe with its various views is shown and its profiling settings are discussed.

https://youtu.be/2qoNfW49C_o

This screen cast shows how to analyze memory leaks in Java applications or reduce memory consumption in general if the objects of interest are not all referenced in the same way.

Analyzing a single object and finding the path to a garbage collector root is not enough in that case and the merged incoming references view as well as the merged dominating reference view are helpful in finding out about the distribution of the actual incoming references and how to make a maximum of objects eligible for garbage collection.

https://youtu.be/aBua8XF2zdY