Jeyzer DEMOS

5 Jeyzer demo apps to discover Jeyzer.

Jeyzer is always deployed with 5 Java demo applications documented in the left panels.
Those permit to train yourself with the Jeyzer ecosystem :

  • Start the application : the Jeyzer Recorder Agent is automatically loaded.
    The recording starts.
  • Wait for the application’s end.
    Or feel free to stop and restart it.
  • Get the JZR recording or the JFR recording and upload it in the Jeyzer Web Analyzer.
  • Generate the JZR report and open it : that’s it !!
    You just did a post mortem analysis. 

Now the real time analysis :

  • Start the demo application along with the Jeyzer Monitor process, in any order.
  • Just wait until the Jeyzer Monitor detects a critical incident: this will trigger the JZR report creation.
  • Generated JZR report will be made available through email and/or web channels.

Think about it : a post mortem analysis requires 2 manual steps : collect and analyze.
                               The real time one : zero. It is fully automatic. Isn’t it magic ?

See the Resources section to get the start commands and storage locations.
If you do not have Jeyzer installed, recordings labors and features demo recordings are available here for an online analysis.

Explore the Java Virtual Threads with Jeyzer.

  • Demo execution : the Virtual Threads demo executes classical Loom tests.
    Java 21 is required to run the Virtual Threads demo.
    The recording must be performed with the JDK jcmd tool.
  • Demo goal : cover 7 test sequences in 2 main topics
    — 1 Massive number of virtual threads sleeping, working (with 1 and 2 executors), accessing I/O
    — 2 Locking inside the virtual threads : the spinning synchronization case, the reentrant lock case and the deadlock case
  • JZR report : check the different cases from functional and technical view : look at the virtual threads sheet.

The Virtual Threads demo is derived from Bazlur Rahman’s demo code.
The I/O sequence code has been courtesy redesigned and enriched by José Paumard (Paris JUG).

The most interesting demo as it permits to validate the Jeyzer’s incident detection strength.
Tip : Feel free to use this demo to test today your own incident detection solution(s). Just to compare.

  • Demo execution : the Labors demo generates randomly 3 incidents.
    Those are printed in the console at demo start and published in the JZR recording.
    In parallel, some standard noise activity is happening all along the demo session.
  • Demo goal : Jeyzer must detect the 3 incidents and reflect it in the JZR report.
  • JZR report : check the Detected incidents and Monitoring Sequence panels.
    You should see there at least 3 incident events listed, along with their explanation and remediation actions.
    The original incident list – published in the JZR recording as a process card property – is available in the Process card panel.

The Labors demo is able to execute around 90 different incident types like the classic deadlock, thread leaks,
database contentions, CPU bursts at task/process/system level, applicative emited events, wrong/missing Xmx, problematic library/module version…

Labors is making reference to the Labours of Heracles.

This demo permits to discover all the JZR report features. Demo theme is aircraft based.
The JZR report is an arcade fire of features and data display : take your time to browse it and appreciate.

  • Demo execution : the Features demo generates a multitude of actions.
    It also emits events through the Jeyzer Publisher library.
  • Demo goal : Jeyzer must provide a smart and complete display of the demo activity.
  • JZR report : check all the panels (up to 36 !). Navigate through events and threads.
    This demo JZR report exists in 2 versions (*) to show that JZR reports can be set up for different audiences.
    Each one is a view of the application under certain angles : event, thread, metrics (CPU, memory, GC..), JMX data, profiling, histograms..

(*) The Features demo is delivered with 2 master profiles :
– demo-features: contains standard Jeyzer features
– demo-features-mx: it includes the exploitation of MX data as well as a discovery mode.

Jeyzer discovery mode:
If you do not have any applicative profile, you can still give applicative keywords at analysis time.
Here, part of the demo – from applicative point of view – is totally unknown for the demo-features profiles.
That part of the app is related to airplane companies : enter related keywords (Airbus, Boeing..) in the Jeyzer Web Analyzer to highlight those in the Discovery panel of the JZR report.
Discovery mode is not available in the Jeyzer Online Web Analyzer.

This demo is basically an academic exercise.
It focuses on the scalability of a multi-threaded design in a flow control approach.
Theme is car toll driven : cars (dynamic thread pool A) do arrive at a toll where agents (dynamic thread pool B) collect the money. A toll manager supervises the agents.

  • Demo execution : the Toll demo generates dynamically Car and Toll Agent threads which interact all togeither, following a state flow diagram. A Toll Manager (controller thread) tries to adapt the staff of agents (*) based on the random flux of incoming cars which is oviously rush hour driven.
    When active, Cars and Toll Agent threads do consume respectively CPU and memory.

  • Demo goal : Jeyzer must provide a smart view of the thread interactions and contentions.
    Typically a production case.

  • JZR report : check all the thread panels to highlight the several technical or functional demo design defects.

(*) Randomly, agents can decide to take a coffee pause, making the challenge a bit more difficult for the Toll Manager.

This demo is another academic exercise illustrating the dining philosophers problem , meaning the deadlock over resources.
Several scenarios get covered, including the Dijkstra solution.

  • Demo execution : the Philosophers demo runs 5 threads – the Philosophers – that access 5 shared resources – the bowls of rice – with a lock (synchronized methods here).
    The different scenarios get executed : the ordered access (Dijkstra solution), twice a random access and finally the perfect deadlock.
  • Demo goal : Jeyzer must provide a smart view of the different scenarios and detect the deadlock. 
  • JZR report : look at the functional (philosopher takes a bowl..) and technical (Java stacks and locks) views across the different report panels. Deadlock will appear as red in many places.

All demo source code is available on github and within the Jeyzer installation. To catch up with the Jeyzer monitoring, see these demo exercises. Some demo JZR recordings are also available here if you wish to test the Jeyzer Online Analyzer. Installation The Jeyzer installer deploys the demo applications within the jeyzer/demo directory. Jeyzer installation paths of interests are :
Category Description Directory
Demo Demo start scripts (sh/bat) demo/bin
Demo Samples : JZR recording and report demo/samples
Monitoring Start scripts customized for the demos (sh/bat) jeyzer/analyzer/bin/preset/profile
Recording JZR recording (zip/tar.gz file) work/recordings/profile/archive
Recording JZR in progress recording (JZR snapshots) work/recordings/profile
Recording Java Flight Recording (JFR) work/recordings/profile/jfr
Recording Jcmd periodic (Virtual threads/Java 21+) recorder/bin/jcmd-periodic.bat
Monitoring JZR generated reports work/recordings/profile/analysis
Monitoring Other generated resources work/recordings/profile/monitor
Web analysis Work directory work/web/analysis/profile
Analysis Master and shared profiles profiles/demo
Analysis Shared profile repository profiles/shared-repositories
Recording Recording profiles demo/config/record/profiles
Recording Agent configurations demo/config/record/agent
Analysis Log file analysis/log
Monitoring Log file work/recordings/profile/log
Source Demo source code demo/src
Profiles Demos do provide complete Jeyzer profile material for recording and analysis. Each demo is shipped with its respective master profile. Demo Features has even 2 master profiles for standard and advanced analysis. A demo shared profile is also shipped to illustrate its automatic loading from a dedicated repository at analysis time. This shared profile is linked to the jeyzer-demo-shared project (standard Maven project available on github) and jar library/Java module which is loaded by each demo application.