(function() { var __SPECTOR_Origin_EXTENSION_GetContext = HTMLCanvasElement.prototype.getContext; HTMLCanvasElement.prototype.__SPECTOR_Origin_EXTENSION_GetContext = __SPECTOR_Origin_EXTENSION_GetContext;
if (typeof OffscreenCanvas !== 'undefined') { var __SPECTOR_Origin_EXTENSION_OffscreenGetContext = OffscreenCanvas.prototype.getContext; OffscreenCanvas.prototype.__SPECTOR_Origin_EXTENSION_OffscreenGetContext = __SPECTOR_Origin_EXTENSION_OffscreenGetContext;
OffscreenCanvas.prototype.getContext = function () { var context = null; if (!arguments.length) { return context; }
if (arguments.length === 1) { context = this.__SPECTOR_Origin_EXTENSION_OffscreenGetContext(arguments[0]); if (context === null) { return context; } } else if (arguments.length === 2) { context = this.__SPECTOR_Origin_EXTENSION_OffscreenGetContext(arguments[0], arguments[1]); if (context === null) { return context; } }
var contextNames = ["webgl", "experimental-webgl", "webgl2", "experimental-webgl2"]; if (contextNames.indexOf(arguments[0]) !== -1) { // context.canvas.setAttribute("__spector_context_type", arguments[0]); // Notify the page a canvas is available. var myEvent = new CustomEvent("SpectorWebGLCanvasAvailableEvent"); document.dispatchEvent(myEvent); this.id = "Offscreen"; window.__SPECTOR_Canvases.push(this);
if (captureOnLoad) { // Ensures canvas is in the dom to capture the one we are currently tracking. if (false) { spector.captureContext(context, 500, false, false); captureOnLoad = false; } } }
return context; } }
HTMLCanvasElement.prototype.getContext = function () { var context = null; if (!arguments.length) { return context; }
if (arguments.length === 1) { context = this.__SPECTOR_Origin_EXTENSION_GetContext(arguments[0]); if (context === null) { return context; } } else if (arguments.length === 2) { context = this.__SPECTOR_Origin_EXTENSION_GetContext(arguments[0], arguments[1]); if (context === null) { return context; } }
var contextNames = ["webgl", "experimental-webgl", "webgl2", "experimental-webgl2"]; if (contextNames.indexOf(arguments[0]) !== -1) { context.canvas.setAttribute("__spector_context_type", arguments[0]); // Notify the page a canvas is available. var myEvent = new CustomEvent("SpectorWebGLCanvasAvailableEvent"); document.dispatchEvent(myEvent);
if (captureOffScreen) { var found = false; for (var i = 0; i
(function() { var __SPECTOR_Origin_EXTENSION_GetContext = HTMLCanvasElement.prototype.getContext; HTMLCanvasElement.prototype.__SPECTOR_Origin_EXTENSION_GetContext = __SPECTOR_Origin_EXTENSION_GetContext;
if (typeof OffscreenCanvas !== 'undefined') { var __SPECTOR_Origin_EXTENSION_OffscreenGetContext = OffscreenCanvas.prototype.getContext; OffscreenCanvas.prototype.__SPECTOR_Origin_EXTENSION_OffscreenGetContext = __SPECTOR_Origin_EXTENSION_OffscreenGetContext;
OffscreenCanvas.prototype.getContext = function () { var context = null; if (!arguments.length) { return context; }
if (arguments.length === 1) { context = this.__SPECTOR_Origin_EXTENSION_OffscreenGetContext(arguments[0]); if (context === null) { return context; } } else if (arguments.length === 2) { context = this.__SPECTOR_Origin_EXTENSION_OffscreenGetContext(arguments[0], arguments[1]); if (context === null) { return context; } }
var contextNames = ["webgl", "experimental-webgl", "webgl2", "experimental-webgl2"]; if (contextNames.indexOf(arguments[0]) !== -1) { // context.canvas.setAttribute("__spector_context_type", arguments[0]); // Notify the page a canvas is available. var myEvent = new CustomEvent("SpectorWebGLCanvasAvailableEvent"); document.dispatchEvent(myEvent); this.id = "Offscreen"; window.__SPECTOR_Canvases.push(this);
if (captureOnLoad) { // Ensures canvas is in the dom to capture the one we are currently tracking. if (false) { spector.captureContext(context, 500, false, false); captureOnLoad = false; } } }
return context; } }
HTMLCanvasElement.prototype.getContext = function () { var context = null; if (!arguments.length) { return context; }
if (arguments.length === 1) { context = this.__SPECTOR_Origin_EXTENSION_GetContext(arguments[0]); if (context === null) { return context; } } else if (arguments.length === 2) { context = this.__SPECTOR_Origin_EXTENSION_GetContext(arguments[0], arguments[1]); if (context === null) { return context; } }
var contextNames = ["webgl", "experimental-webgl", "webgl2", "experimental-webgl2"]; if (contextNames.indexOf(arguments[0]) !== -1) { context.canvas.setAttribute("__spector_context_type", arguments[0]); // Notify the page a canvas is available. var myEvent = new CustomEvent("SpectorWebGLCanvasAvailableEvent"); document.dispatchEvent(myEvent);
if (captureOffScreen) { var found = false; for (var i = 0; i
(function() { var __SPECTOR_Origin_EXTENSION_GetContext = HTMLCanvasElement.prototype.getContext; HTMLCanvasElement.prototype.__SPECTOR_Origin_EXTENSION_GetContext = __SPECTOR_Origin_EXTENSION_GetContext;
if (typeof OffscreenCanvas !== 'undefined') { var __SPECTOR_Origin_EXTENSION_OffscreenGetContext = OffscreenCanvas.prototype.getContext; OffscreenCanvas.prototype.__SPECTOR_Origin_EXTENSION_OffscreenGetContext = __SPECTOR_Origin_EXTENSION_OffscreenGetContext;
OffscreenCanvas.prototype.getContext = function () { var context = null; if (!arguments.length) { return context; }
if (arguments.length === 1) { context = this.__SPECTOR_Origin_EXTENSION_OffscreenGetContext(arguments[0]); if (context === null) { return context; } } else if (arguments.length === 2) { context = this.__SPECTOR_Origin_EXTENSION_OffscreenGetContext(arguments[0], arguments[1]); if (context === null) { return context; } }
var contextNames = ["webgl", "experimental-webgl", "webgl2", "experimental-webgl2"]; if (contextNames.indexOf(arguments[0]) !== -1) { // context.canvas.setAttribute("__spector_context_type", arguments[0]); // Notify the page a canvas is available. var myEvent = new CustomEvent("SpectorWebGLCanvasAvailableEvent"); document.dispatchEvent(myEvent); this.id = "Offscreen"; window.__SPECTOR_Canvases.push(this);
if (captureOnLoad) { // Ensures canvas is in the dom to capture the one we are currently tracking. if (false) { spector.captureContext(context, 500, false, false); captureOnLoad = false; } } }
return context; } }
HTMLCanvasElement.prototype.getContext = function () { var context = null; if (!arguments.length) { return context; }
if (arguments.length === 1) { context = this.__SPECTOR_Origin_EXTENSION_GetContext(arguments[0]); if (context === null) { return context; } } else if (arguments.length === 2) { context = this.__SPECTOR_Origin_EXTENSION_GetContext(arguments[0], arguments[1]); if (context === null) { return context; } }
var contextNames = ["webgl", "experimental-webgl", "webgl2", "experimental-webgl2"]; if (contextNames.indexOf(arguments[0]) !== -1) { context.canvas.setAttribute("__spector_context_type", arguments[0]); // Notify the page a canvas is available. var myEvent = new CustomEvent("SpectorWebGLCanvasAvailableEvent"); document.dispatchEvent(myEvent);
if (captureOffScreen) { var found = false; for (var i = 0; i
Grundlagen
Profiling Arten
Es können verschiedene Arten von Profiling unterschieden werden.
- CPU Profiling: Das CPU Profiling zeigt auf wo die Anwendung wie viel Rechenzeit verwendet. Meistens wird diese Metrik auf einer Funktion- oder Methodenebene betrachtet.
- Memory Profiling: Das Memory Profiling zeigt auf was wie viel Speicher verbraucht. Desweiteren geht es um Informationen wie Speicher verwaltet wird. Stichwörter sind hier “Memory Allocation” und “Garbage Collection”. Ein Ziel ist oft auch sogenannte “Memory Leaks” zu finden.
- Async Profiling: Beim Async Profiling geht es darum die koordination von Abläufen zu verstehen. Ein Beispiel dafür ist das Zusammenspiel von verschiedenen Threads.
- Higher Level Profiling: Beim Higher Level Profiling geht es darum das Verhalten von technischen Anwendungsfunktionen zu überwachen. Zum Beispiel das Ausführen von Abfragen gegen eine Datenbank (JDBC, JPA, …), Webrequests (Servlets, …) oder das werfen von Ausnahmen.
- Application Profiling: Beim Application Profiling geht es darum das Verhalten der eigenen Anwendungslogik ersichtlich zu machen. Dazu müssen oft eigene im Kontext sinnvolle Metriken in der Anwendung implementiert werden.
Einsatzvarianten
Je nach Situation können Profiler auf verschiedene Arten eingesetzt werden.
- Attached: Es wird ein Prozess gestartet der mit dem entsprechenden Profiler präperiert (instrumentalisiert) ist.
- Local: Der Profiler stellt eine Verbindung zu einem bereits lokal laufenden JVM Prozess her.
- Remote: Der Profiler stellt über ein entsprechendes Protokoll eine Verbindung zu einem entfernt laufenden Prozess her. Dazu muss das Protokoll auf der Serverseite entsprechend eingerichtet sein.
- Snapshot: Man erzeugt zu einem Zeitpunkt ein Abbild eines Systemes um dann das Abbild im Detail auszuwerten. Da ein Snapshot nur einen Zeitpunkt erfasst können die darin enthaltenen Informationen sehr detailiert sein. Ein spezieller Snapshot sind Java Flight Recorder Aufnahmen. Die Informationen und Metriken werden durch ein Programm über einen Zeitraum gesammelt und in einer Datei zwischengespeichert. Später können die Daten dann in einem Profiler ausgewertet werden. Besonders bei resourcenintensive Erhebungen ist es oft eine gute Option gezielte und kurze Aufnahmen zumachen.
Java Mission Control
Das Java Mission Control (JMC) ist eine auf Eclipse RCP aufbauende Oberfläche zum Überwachen und Auswerten von Java Anwendungen. Früher war die JMC Anwendung ein Teil des kommerziellen JDK Paketes von Oracle. Inzwischen ist das Programm unter einer OpenSource Lizenz verfügbar. Eine Besonderheit ist, dass das Werkzeug hauptsächlich für die Auswertung von Java Flight Recorder Events gedacht ist, wodurch sich sehr flexibel verschiedene Metriken abbilden lassen.
Java Mission Control kann auf der Seite von AdoptOpenJdk kostenlos heruntergeladen werden: https://adoptopenjdk.net/jmc.html
Da die Anwendung auf Eclipse basiert gibt es auf der Seite auch die Option die Anwendung als Plugin in die Eclipse Java Entwicklungsumgebung zu integrieren.
| Attached | Local | Remote | Snapshot |
|---|---|---|---|
| JVM Option | Ja | JMX | *.hprof, *.jfr, *.persisted_jmx_data |
*.hprof= HProf Snapshots*.jfr= JDK Flight Recordings*.persisted_jmx_data= Persisted JMX Data
Pro:
- Kostenlos: Inzwischen ist das Programm als Open Source Software verfügbar und ist damit leicht zugänglich.
- Eclipse Integration: Da die Anwendung auf der Eclipse Rich Client Platform basiert fühlt man sich als Eclipse IDE Nutzer direkt wohl. Die Anwendung kann daher auch als Plugin direkt in die Eclipse IDE integriert werden.
- JFR als starke Basis: Die JMC Anwendung baut auf JFR Events auf welche direkt über das JDK breit unterstützt werden. Das Ökosystem rund um JFR Events wächst immer weiter. Eigene Metriken lassen sich einfach durch die über das JDK bereitgestellten APIs erweitern und verarbeiten.
- Automated Analysis Results: Der JMC liefert automatische Bewertungen der Metriken bzw. Handlungsempfehlungen über sogenannte Rules. Eigene Rules können implementiert werden.
Contra:
- Unbeliebt bei Bitdefender: Der Bitdefender auf meinem Firmenrechner fand die standalone Variante des JMC nicht so toll und hat es in Quarantäne geschoben.
- Manchmal zu generisch, mächtig und flexibel: Die Oberfläche des JMC ist teilweise sehr generisch um möglichst flexibel und mächtig mit JFR Events umgehen zu können. Daher scheint der Umgang manchmal ein wenig kompliziert und verschachtelt.
Screenshots
Automated Analysis Results
Eclipse IDE Plugin Integration
VisualVM
Bei VisualVM handelt es sich um eine auf der Netbeans Plattform aufbauende Oberfläche zum Überwachen und Auswerten von Java Anwendungen. VisualVM ist als Open Source Anwendung verfügbar. In Java 6 bis 8 war VisualVM ein Bestandteil des JDK Paketes. Seit Java 9 ist das Programm separat verfügbar.
VisualVM kann auf der folgenden Seite kostenlos heruntergeladen werden: https://visualvm.github.io/download.html
| Attached | Local | Remote | Snapshot |
|---|---|---|---|
| Ja | Ja | jstatd, JMX | *.apps, *.jfr, Core Dumps |
.apps= Application Snapshots*.jfr= JDK Flight Recordings- Core Dumps = Thread und Memory Dumps
Pro:
- Kostenlos: Das Programm ist inzwischen als Open Source Anwendung verfügbar und damit einfach zugänglich.
- Solide und stimmige Funktionen: Gerade im Bereich des CPU und Memory Profiling funktioniert VisualVM sehr gut und liefert sehr solide Werkzeuge.
- JFR Events: Kann grundlegend JFR Events aus einem Snapshot anzeigen.
- Erweiterungen / Plugins: Einige Erweiterungen, z.B. der MBean Browser, ergänzen weitere solide Funktionen.
Contra:
- Wenig Funktionen zum Application Profiling bzw. High Level Profiling: Allgemein kann man z.B. über MBeans sicher auf einer generischen Ebene alles Mögliche betrachten. Spezielle Funktionen oder Presets fehlen hier aber.
Screenshots
Einstiegspunkte
JProfiler
Der JProfiler ist ein kommerzielles Produkt von der 2001 gegründeten Firma ej-technologies mit Firmensitz in München.
Neben Kostenpflichtigen Lizenzen kann das Werkzeug zum Untersuchen und Auswerten von Java Anwendungen für einige Tage kostenlos getestet werden. Die Installation erfolgt komfortabel über einen Installer, der es auch direkt ermöglicht Erweiterungen in gängige Entwicklungsumgebungen zu installieren. Hier kann das Programm heruntergeladen werden: https://www.ej-technologies.com/download/jprofiler/files
Eigene Metriken können über das JMX/MBean Protokol oder über sogenannte Probes integriert werden.
| Attached | Local | Remote | Snapshot |
|---|---|---|---|
| Main Class, Jar, Class path, Application Server Integration | Ja | SSH, Profiling Agent | *.jps, *.hprof, *.bin, *.hpz, *.phd, *.jfr |
*.jps= JProfiler Snapshots*.hprof,*.bin= HProf Snapshots*.hpz= Compressed HProf Snapshots*.phd= IBM PHD Snapshots*.jfr= JDK Flight Recordings
Pro:
- Übersichtlich: Die Oberfläche ist übersichtlich. Über die Navigation auf der linken Seite kommt man direkt zu den verschiedenen Bereichen und Funktionen.
- Demo Anwendung: Um sich mit dem JProfiler vertraut zu machen gibt es die Option direkt aus der Anwendung heraus eine Demoanwendung zu starten welche es erlaubt das Verhalten bzw. die Last zu steuern und mit dem Profiler zu untersuchen.
- Kostenlos vollen Umfang testen: Eine Trial Lizenz erlaubt es den JProfiler für einige Tage im vollen Umfang zu testen.
- Datenbankabfrage Analyse: Der JProfiler versteht Datenbankabfragen bei einigen gängigen Frameworks und Datenbanken out-of-the-box und zeigt die Laufzeit der Abfragen übersichtlich an. Dadurch kann man schnell eventuelle Flaschenhälse ausfindig machen. Siehe Screenshots.
- JMX/MBean Unterstützung: Metriken die bereits über JMX bzw. MBeans verfügbar sind können in den JProfiler integriert werden.
Contra:
- Zeigt keine Events in JFR Snapshots an
- Preis: Aufgrund der verfügbaren (kostenlosen) Alternativen finde ich den Preis nicht sonderlich attraktiv. Gerade grundlegende Analysen wie z.B. CPU und Memory machen auch die kostenlosen Programme relativ gut.
Screenshots
Einstiegspunkte
Datenbank Profiling
YourKit Java Profiler
Der YourKit Java Profiler ist ein kommerzielles Produkt von der 2003 gegründeten Firma YourKit mit Firmensitz in Düsseldorf.
Neben Kostenpflichtigen Lizenzen kann das Werkzeug zum Untersuchen und Auswerten von Java Anwendungen für einige Tage kostenlos getestet werden. Die Installation erfolgt komfortabel über einen Installer der hier heruntergeladen werden kann: https://www.yourkit.com/java/profiler/download
Erweiterungen für gängige Entwicklungsumgebungen stehen zur Verfügung.
Als Grundprinzip verwendet der Profiler sogenannte Probes. Das sind Interceptoren um verschiedene Aspekte einer Anwendung tracken zu können. Neben vordefinierten Probes ist es auch möglich eigene Probes mit Java zu implementieren.
| Attached | Local | Remote | Snapshot |
|---|---|---|---|
| JVM Option, Application Server Integration | Ja | SSH, Profiling Agent | *.snapshot, *.hprof, *.bin, *.phd |
*.snapshot= YourKit Snapshots*.hprof,*.bin= HProf Snapshots*.phd= IBM PHD Snapshots
Pro:
- Erkennt auch alternative VMs wie OpenJ9
- Durch das Konzept von Probes erweiterbar
- Demo Anwendung: Um sich mit dem YourKit Java Profiler vertraut zu machen gibt es die Option direkt aus der Anwendung heraus eine Demoanwendung zu starten welche es erlaubt das Verhalten bzw. die Last zu steuern und mit dem Profiler zu untersuchen.
- Kostenlos vollen Umfang testen: Eine Trial Lizenz erlaubt es den YourKit Java Profiler für einige Tage im vollen Umfang zu testen.
- Inspections: Über diese Funktion macht der YourKit Java Profiler auf bekannte Probleme aufmerksam. So findet man eventuell Probleme ohne eine aufwändige manuelle Auswertung zu starten.
- JFR Event Unterstützung: Neuere Versionen scheinen auch JFR Events zu unterstützen. Die funktion war zum Zeitpunkt des Tests noch nicht verfügbar.
Contra:
- Verschachtelte, überladene Oberfläche: Mir viel es nicht immer leicht den richtigen Ort in der Oberfläche zu finden.
- Teilweise unintuitiv: Zum Beispiel war das View Menü in einem bestimmten Kontext deaktiviert und mir war nicht ersichtlich warum.
- Preis: Aufgrund der verfügbaren (kostenlosen) Alternativen finde ich den Preis nicht sonderlich attraktiv. Gerade grundlegende Analysen wie z.B. CPU und Memory machen auch die kostenlosen Programme relativ gut.
Screenshots
Startseite
Datenbank Profiling
Inspections
Probes
Lizenzen
| Produkt | Lizenz | Preis | Beschreibung |
|---|---|---|---|
| Java Mission Control | OpenSource | 0€ | Kostenlos |
| VisualVM | OpenSource | 0€ | Kostenlos |
| JProfiler | Single License | 420€ | Ein Entwickler, mehrere Installationen |
| JProfiler | Floating License | 1750€ | Mehrere Entwickler, eine aktive Instanz |
| JProfiler | Trial | 0€ | 10 Tage testen |
| YourKit Java Profiler | Single License | 459€ | Ein Entwickler, eine Installation |
| YourKit Java Profiler | Floating License | 2299€ | Mehrere Entwickler, eine aktive Instanz |
| YourKit Java Profiler | Trial | 0€ | 15 Tage testen |
- Beim Kauf von mehreren Lizenzen gibt es einen Mengenrabatt
- Support kostet teilweise extra
- Upgrades von früheren Versionen gibt es vergünstigt
Fazit
Erstaunlich, dass es gleich 4 wirklich sehr gute Java Profiler gibt die alle einen kompetenten Eindruck hinterlassen. Interessant ist auch, dass diese auf den verschiedenen IDE Plattformen (Eclipse, Netbeans und IntelliJ) aufbauen. Durch einen Open Source Ruck in der Java Welt sind zwei der vier Tools kostenlos zugänglich. Und hier liegt aus meiner Sicht auch der Knackpunkt. Die kostenlosen Programme sind so gut und solide, dass ich damit für die meisten Aufgaben schon sehr gut und zukunftssicher ausgestattet bin. Da erscheinen mir die Lizenzmodelle der kostenpflichtigen Alternativen wenig att
This post first appeared on DoubleSlash IT Business Und Software, please read the originial post: here
