Willkommen beim Wegerl.at 'Lesemodus'!
Entspanntes Lesen und spannende Artikel warten auf dich.
Entdecke unsere besten BeitrĂ€ge und genieße den Lesemodus.
Page Load Stats

WP Page Load Stats 7:
Website-Performance im Blick

Speedometer, Fotorech
Info echo
OpenClipart-Vectors-katze-1

Ist der Classic-Editor schon zu kennen? –
"Advanced Editor Tools – ist so klasse!"
Anklickt! – Advanced Editor Tools; und NEU! – Classic Widgets

Info echo
OpenClipart-Vectors-katze-2

Anklickt Classic-Editor mit Advanced Editor Tools
"Advanced Editor Tools – ist das ausgezeichnete!"
Anklickt! – Advanced Editor Tools; und NEU! – Classic Widgets

Info echo
OpenClipart-Vectors-katze-3

Klassischen Editor anwenden! – und 

"Advanced Editor Tools – ist so sehr gut !"
Anklickt! – Advanced Editor Tools; und NEU! – Classic Widgets

Info echo
OpenClipart-Vectors-katze-7


 die Welt gehört dem, der sie genießt.
"Advanced Editor Tools – und tut sehr gut!"
Anklickt! – Advanced Editor Tools; und NEU! – Classic Widgets

Info echo
OpenClipart-Vectors-katze-4

Advanced Editor Tools aktive Installationen: 2+ Millionen
"Advanced Editor Tools – ist so fabelhaft!"
Anklickt! – Advanced Editor Tools; und NEU! – Classic Widgets

Info echo
OpenClipart-Vectors-katze-5

Ansprechend! – so gehts hier zur Lancierung
"Advanced Editor Tools – ist de luxe!"
Anklickt! – Advanced Editor Tools; und NEU! – Classic Widgets

Info echo
OpenClipart-Vectors-katze-6


 und NEU! – Classic Widgets
"Classic Widgets – sind so grandiose!"
Anklickt! – Advanced Editor Tools; und NEU! – Classic Widgets

Info echo
OpenClipart-Vectors-katze-8a

Werkraum ist Werkraum und Frontend ist Frontend
Katzen SVG OpenClipart-Vectors; Ticker von Ditty News Ticker
"Advanced Editor Tools – ist so fein!"
Anklickt! – Advanced Editor Tools; und NEU! – Classic Widgets

Das Plug-in WP Page Load Stats bietet den Besuchern einer Website einen Einblick in die Hintergrundprozesse wĂ€hrend der Seitenladung. Es zeigt wichtige Leistungsmetriken an, die Aufschluss darĂŒber geben, wie effizient und reaktionsschnell die Website arbeitet. Durch die Überwachung dieser Metriken wird Klarheit darĂŒber gewonnen, welche ZusammenhĂ€nge es zur Page Load Time gibt. Website-Betreiber können potenzielle Leistungsprobleme erkennen und Optimierungen vornehmen, um die Benutzererfahrung zu verbessern.

Die Bedeutung der Ladezeit und die Leistung einer Website sind vielen von uns besusst. Das WP Page Load Stats Plug-in war in der Vergangenheit eine zuverlĂ€ssige Option, um genau das zu tun. Leider hat dieses nĂŒtzliche Tool in den letzten Jahren seinen Dienst eingestellt, und die KompatibilitĂ€t mit den neuesten PHP-Versionen wurde zum Problem.

WP Page Load Stats

Mit PHP 8 verlor das Plugin vollends seine FunktionalitÀt, da der Code nicht mehr den neuesten PHP-Standards entsprach.


Das grundlegende Plug-in zur folgenden FunktionalitÀt ist auch hier zum Download wp-page-load-stats.1.0.2


WP Page Load Stats – Einblicke in Website-Performance fĂŒr Webmaster und Besucher.

Servus, ich bin das 'Helferlein'!

Aber zum GlĂŒck gibt es immer noch eine Möglichkeit, dieses hilfreiche Tool weiterhin zu nutzen! Dank der UnterstĂŒtzung von ChatGPT, einem fortschrittlichen KI-Modell, konnte eine aktualisierte Version des Plug-ins erstellt werden, die mit PHP 8 und sogar den neuesten PHP-Versionen kompatibel ist. Mit einigen Anpassungen konnte das Plug-in wieder zum Leben erweckt werden und bietet uns die Möglichkeit, die Leistung unserer Website auch weiterhin im Blick zu behalten.

Hallo, ich bin da "Wegerl"!

Wir freuen uns, dir diese aktualisierte Version von 'WP Page Load Stats' + das interne 'WP Page Load Stats 7' und 'WP Page Load Stats 9' Plug-in prĂ€sentieren zu können. Wir möchten jedoch darauf hinweisen, dass der ursprĂŒngliche Autor das Plug-in nicht mehr unterstĂŒtzt, und wir es daher als 'Inoffizielle Version' anbieten. Obwohl wir unser Bestes tun, um das Plug-in funktionsfĂ€hig zu halten, können wir keine Garantie fĂŒr zukĂŒnftige Updates oder Fehlerbehebungen geben.

WP Page Load Stats originÀrInoffizielle Version
WP Page Load Stats 7 MetrikenInterne Version
WP Page Load Stats 9 MetrikenInterne Version

Wir möchten an dieser Stelle ein herzliches Dankeschön an Mike Jolley aussprechen, den ursprĂŒnglichen Autor von "WP Page Load Stats". Obwohl das Plug-in nicht mehr offiziell unterstĂŒtzt wird, bietet er es immer noch zum Download an. Seine Arbeit hat die Grundlage fĂŒr die Entwicklung der 'Inoffizielle Versionen' und 'Interene Version (WP Page Load Stats 7 und 9)' geschaffen, die wir hier zur VerfĂŒgung stellen.

So gehst du vor,
um das Plug-in zu verwenden

Gehe ĂŒber "Plug-ins" Installieren zum Pluginverzeichnis und suche nach "WP Page Load Stats Mike Jolley".

  • Nach dem Installieren bitte nicht aktivieren, wenn du einen Server ab PHP 8 hast. Andernfalls könnte es zu einem Fatal Error kommen.

Sobald das Plug-in installiert ist, gehe ĂŒber das WordPress-Dashboard zu "Plugins" in der linken Seitenleiste. Klicke auf "Plugin-Datei-Editor" und wĂ€hle das Plug-in "WP Page Load Stats" aus der Dropdown-Liste. Die Datei wp-page-load-stats.php wird angezeigt. Lösche den gesamten Inhalt dieser Datei und fĂŒge den hier kopierten Code ein. Speichere die Änderungen ab und aktiviere das Plug-in anschließend ĂŒber das Dashboard unter "Plugins > Installierte Plugins".

Bevor wir uns den Programmierungscodes zuwenden, befassen wir uns mit den Details der Leistungsmetriken und geben ErlÀuterungen zum Plug-in.

Leistungsmetriken (Interne Version)

Es geht darum, die gemessenen Daten zu verstehen und zu interpretieren.

Hier bieten wir eine leicht abgeÀnderte Version der Metriken von WP Page Load Stats an. Die Metriken umfassen zum Beispiel:

    1. Serverreaktion: 0,200 sec.
    2. DB-Abfrage: 0,138 sec.
    3. 355 Abfragen

    4. 
in 0,293 sec.
    5. Serverantwort: 0,294 sec.
    6. Page Load Time: 1,121 sec.
    7. Mem Usage: 21,08 MB (8,23 %).

Die Leistungsmetriken unter der Lupe sieh folgend im Scrolle:

  1. "Serverreaktion": 0,200 sec.

Die Serverreaktion gibt an, wie schnell der Server auf eine Anfrage reagiert und mit dem Laden der Seite beginnt. Es ist die Zeit, die der Server benötigt, um die Anfrage zu verarbeiten und die ersten Daten an den Browser des Besuchers zu senden.

  • Eine niedrige Serverreaktion ist von entscheidender Bedeutung, um eine schnelle Website zu gewĂ€hrleisten. Wenn die Serverreaktion hoch ist, kann dies zu Verzögerungen beim Laden der Seite fĂŒhren und sich negativ auf die Benutzererfahrung auswirken.

Die Serverreaktion hier auf dieser Website betrĂ€gt konstant etwa 0,200 Sekunden. Um festzustellen, ob diese Zeit ĂŒberhaupt eine Abweichung ist, sollten die Dezimalstellen erhöht werden. Diese Anpassung kann im Code vorgenommen werden.

  1. "DB-Abfrage": 0,138 Sekunden

Das ist die Datenbankabfragezeit. Diese Metrik zeigt die Effizienz der Datenbanknutzung an. Der Wert gibt die Gesamtzeit an, die benötigt wurde, um die Datenbankabfragen zu bearbeiten. Er bezieht sich ausschließlich auf die Zeit, die fĂŒr die Datenbankabfragen aufgewendet wurde, und nicht auf andere Dateien oder ServervorgĂ€nge.

  • Eine optimierte Datenbankabfragezeit trĂ€gt zur Verbesserung der Gesamtperformance der Website bei.

Hinweis: Es ist möglich, dass die Datenbankabfragezeit nicht angezeigt wird, wenn die Seite sehr schnell geladen wird. Dies liegt daran, dass die Messung der Datenbankabfragezeit in der Regel auf dem Zeitpunkt basiert, wenn die Seite generiert wird und Datenbankabfragen durchgefĂŒhrt werden. Wenn die Seite jedoch sehr schnell geladen wird, können diese Datenbankabfragen bereits abgeschlossen sein, bevor die Messung beginnt. In diesem Fall wĂ€re selbst eine Erhöhung der Dezimalstellen zwecklos.

  1. 355 "Abfragen"


Dieser Wert zeigt die Gesamtzahl der Datenabfragen an, die wĂ€hrend der Seitenladung ausgefĂŒhrt wurden. Es handelt sich um alle Abfragen, die sowohl die Dateien auf dem Server (z. B. Medien, Plug-ins und andere Ressourcen) als auch die Datenbank betreffen können.

  • Datenabfragen umfassen verschiedene VorgĂ€nge, bei denen die Website Informationen von der Datenbank oder anderen Serverressourcen abruft, um die Webseite vollstĂ€ndig darzustellen. Diese Abfragen können das Laden von Seiteninhalten, Bildern, CSS-Dateien, JavaScript und anderen Dateien umfassen, die fĂŒr das ordnungsgemĂ€ĂŸe Funktionieren der Webseite sind.
  • Die Anzahl der Abfragen ist ein weiterer Indikator fĂŒr die Effizienz und Leistung der Website. Je weniger Abfragen eine Webseite wĂ€hrend der Ladezeit ausfĂŒhren muss, desto schneller und reibungsloser kann die Seite geladen werden. Durch die Optimierung der Anzahl der Abfragen können Ladezeiten verkĂŒrzt und die Benutzererfahrung verbessert werden.
  • Dies kann beispielsweise durch das Minimieren von HTTP-Anfragen, das Zusammenfassen von CSS- und JavaScript-Dateien und den effizienten Einsatz von Caching-Techniken erreicht werden. Eine effiziente Datenabfrage reduziert auch die Serverbelastung und kann Kosten sparen, insbesondere in Bezug auf Hosting-Ressourcen.

Daher ist es wichtig, die Anzahl der Abfragen zu ĂŒberwachen und bei Bedarf Maßnahmen zu ergreifen, um die Leistung der Website zu optimieren und eine bessere Benutzererfahrung zu bieten. Tools wie WP Page Load Stats können dabei helfen, diese Metrik zu analysieren und Optimierungspotenzial zu identifizieren.

  1. 
in 0,293 Sekunden

Dieser Wert gibt die Gesamtzeit an, die sich aus der Gesamtzahl der Datenabfragen (259 Abfragen) ergibt, einschließlich aller VorgĂ€nge, die sowohl Dateien als auch Datenbank betreffen. Die Gesamtzeit der Datenabfragen reprĂ€sentiert die kumulierte Zeit, die benötigt wird, um sĂ€mtliche Informationen und Ressourcen einer Webseite zu laden. Hierbei handelt es sich nicht nur um die Datenbankabfragen, sondern auch um das Abrufen von Dateien wie Plug-ins, Medien und anderen Ressourcen.

  • Die Gesamtzeit der Datenabfragen ist ein wesentlicher Leistungsfaktor fĂŒr die Seitenladungsgeschwindigkeit einer Webseite. Eine niedrige Gesamtzeit der Datenabfragen deutet darauf hin, dass die Website effizient arbeitet und ihre Ressourcen schnell bereitstellt. Dies fĂŒhrt zu einer besseren Benutzererfahrung, da die Seiten schneller geladen werden und Besucher weniger Wartezeit haben.

Um die Gesamtzeit der Datenabfragen zu verbessern, können verschiedene Maßnahmen ergriffen werden, wie die Optimierung von Datenbankabfragen, die Verwendung von Caching-Techniken und das effiziente Laden von Ressourcen. Diese Optimierungen fĂŒhren zu einer schnelleren und reaktionsschneller Website fĂŒr deine Besucher.

  1. "Serverantwort": 0,294 sec.

Die Serverantwort umfasst die Zeit, die der Server gebraucht hat, um alle erforderlichen Daten und Ressourcen fĂŒr die vollstĂ€ndige Darstellung der Seite zu sammeln und an den Browser des Besuchers zu liefern.

  • WĂ€hrend die Serverreaktion die Zeit bis zum Beginn des Ladens der Seite misst, gibt die Serverantwort an, wie lange der Server benötigt hat, um alle Inhalte, Bilder, Skripte und andere Ressourcen der Webseite zu sammeln und an den Browser zu ĂŒbertragen.
  • In diesem Beispiel sind die Reaktionszeit (0,200 Sekunden) und die Antwortzeit (0,294 Sekunden), was in Summe 0,494 Sekunden ergibt. Alle anderen zeitlichen Verzögerungen entstehen vor allem durch den Rendering-Prozess und Ă€hnliche technische Faktoren.

Eine niedrige Serverarbeitzeit ist, um sicherzustellen, dass die Seite schnell und vollstĂ€ndig geladen wird, was zu einer positiven Benutzererfahrung fĂŒhrt.


Ja, die Serverantwortzeit (auch als "Time to First Byte" oder TTFB bezeichnet) kann mit der eigenen Bandbreite zusammenhÀngen, insbesondere wenn du als Benutzer oder Entwickler die Webseite aufrufst. Hier ist, wie die Bandbreite in Bezug auf die Serverantwortzeit eine Rolle spielt:

  • Client-zu-Server-Kommunikation: Wenn du eine Webseite besuchen, sendet Ihr Webbrowser eine Anforderung an den Webserver, um die benötigten Ressourcen wie HTML, CSS, JavaScript und Bilder abzurufen. Die Geschwindigkeit, mit der dein Browser diese Anforderungen senden kann, hĂ€ngt von deiner eigenen Bandbreite ab. Eine schnellere Bandbreite ermöglicht es dir, diese Anfragen schneller zu versenden.
  • Server-zu-Client-Kommunikation: Nachdem der Webserver die Anforderungen erhalten hat, sendet er die entsprechenden Ressourcen als Antwort zurĂŒck an deinen Browser. Die Serverantwortzeit (TTFB) hĂ€ngt von der Bandbreite des Servers ab. Ein Server mit einer höheren Bandbreite kann die Ressourcen schneller an den Client senden.
  • Paketverlust und StabilitĂ€t: Die Bandbreite beeinflusst auch die StabilitĂ€t der Verbindung zwischen deinem Client (Browser) und dem Server. Eine instabile oder niedrige Bandbreite kann zu Paketverlusten und Verzögerungen bei der Kommunikation fĂŒhren, was sich auf die Serverantwortzeit auswirken kann.
  1. "Page Load Time": 1,121 sec.

Die Page Load Time ist die Gesamtzeit, die benötigt wurde, um die gesamte Webseite einschließlich aller Ressourcen und Daten zu laden. Hierbei spielt das Rendering eine entscheidende Rolle, da es ein Teil der 'Page Load Time' ist. Das Rendering bezieht sich auf den Vorgang, bei dem der Browser die heruntergeladenen Daten in sichtbare Inhalte umwandelt und die Webseite fĂŒr den Benutzer darstellt. Dies beinhaltet das Anzeigen von Text, Bildern, Videos und anderen Elementen der Webseite.

  • Eine schnelle Page Load Time und ein effizientes Rendering sind entscheidend fĂŒr eine positive Benutzererfahrung und ein besseres Ranking in den Suchergebnissen.

Um diese Metrik zu optimieren, können verschiedene Maßnahmen ergriffen werden, wie die Reduzierung der DateigrĂ¶ĂŸe von Bildern, die Verwendung von Lazy Loading fĂŒr Bilder und Videos, die Minimierung von JavaScript und CSS-Dateien sowie die Nutzung von modernen Webtechnologien. Durch diese Optimierungen kann die Page Load Time reduziert und die Website schneller und reaktionsschneller gemacht werden.


Die 'Page Load Time' hĂ€ngt eng mit der 'Rendertime' und der 'Time To Interactive' zusammen und wird zudem von der Netzwerkgeschwindigkeit oder Bandbreite beeinflusst, die vom Internetanbieter bereitgestellt wird. Letztere bestimmt, wie schnell Daten ĂŒber das Internet ĂŒbertragen werden können. Die Netzwerkgeschwindigkeit, zusammen mit ihr die 'Page Load Time', kann auch je nach regionalen und zeitlichen Anforderungen an Daten variieren.

  • Wenn die 'Page Load Time' nicht mit anderen Messwerten wie der Serverantwortzeit oder der Datenbankabfragezeit ĂŒbereinstimmt, könnte dies auf die Netzwerkgeschwindigkeit zurĂŒckzufĂŒhren sein. Eine langsame Netzwerkgeschwindigkeit kann lĂ€ngere Ladezeiten zur Folge haben, selbst wenn der Server und andere Ressourcen schnell reagieren.
  • Die 'Page Load Time' wird von der Serverleistung, der GrĂ¶ĂŸe der Ressourcen und vor allem der Netzwerkgeschwindigkeit beeinflusst. Diese Wechselwirkung unterschiedlicher Faktoren trĂ€gt zur Gesamtladezeit bei und kann zu Abweichungen zwischen den gemessenen Werten fĂŒhren.
Serverantwort und Page Load Time

Normalerweise sollte die Page Load Time lÀnger sein als die Serverantwortzeit, da sie die Zeit beinhaltet, die der Server benötigt, um die Ressourcen zu generieren und an den Client zu senden. In anderem Beispiel ist die Serverantwortzeit (1,088 Sekunden) lÀnger als die Page Load Time (0,948 Sekunden), was ungewöhnlich ist.

Mögliche GrĂŒnde fĂŒr diese Diskrepanz könnten sein:

  • Caching: Wenn die Seite oder bestimmte Ressourcen im Cache gespeichert sind, kann dies die Page Load Time verkĂŒrzen, da der Server weniger Arbeit hat. Die Serverantwortzeit bleibt jedoch unverĂ€ndert.
  • Parallelisierung: In einigen FĂ€llen kann der Browser mehrere Ressourcen parallel laden. Dies könnte die wahrgenommene Page Load Time verkĂŒrzen, da einige Ressourcen gleichzeitig geladen werden, wĂ€hrend andere noch auf die Serverantwort warten.
  • Externe Ressourcen: Wenn die Seite externe Ressourcen von Drittanbietern wie Werbenetzwerken oder Analysetools enthĂ€lt, können Verzögerungen beim Laden dieser Ressourcen die Page Load Time verlĂ€ngern.

Ja, und eine Diskrepanz zwischen gemessenen Werten wie der Serverantwortzeit und der Page Load Time kann in einigen FĂ€llen auf Messfehler oder Schwankungen zurĂŒckzufĂŒhren sein. Es gibt mehrere Faktoren, die dazu beitragen können:

  • Serverleistungsschwankungen: Die Serverleistung kann schwanken, abhĂ€ngig von der aktuellen Auslastung, dem Datenverkehr und anderen Faktoren. Dies kann zu Unterschieden in der Serverantwortzeit fĂŒhren, wenn Messungen zu unterschiedlichen Zeiten durchgefĂŒhrt werden.
  • Netzwerkschwankungen: Das Internet ist ein dynamisches Umfeld, und die Netzwerkschwankungen können dazu fĂŒhren, dass die Übertragungsgeschwindigkeit zwischen dem Server und dem Client variiert. Dies kann sich auf die Messungen auswirken.
  • Clientseitige Prozesse: Der Client (der Browser des Benutzers) fĂŒhrt auch verschiedene Prozesse aus, um Ressourcen zu laden und anzuzeigen. Diese Prozesse können je nach Browser und Betriebssystem variieren und zu Unterschieden in der Page Load Time fĂŒhren.
  • Messwerkzeuge und -methoden: Die Genauigkeit der Messwerkzeuge und -methoden kann ebenfalls eine Rolle spielen. Unterschiedliche Messwerkzeuge können leicht unterschiedliche Ergebnisse liefern, und Messungen können von anderen Faktoren wie der Serverkonfiguration und dem Standort des Benutzers beeinflusst werden.

Zusammenfassend ist die Auseinandersetzung mit den Messwerten eine wertvolle Methode, um ein tieferes VerstĂ€ndnis fĂŒr die ZusammenhĂ€nge zu entwickeln, die sich aus ihnen ergeben. Diese Werte können uns grundlegende Erkenntnisse vermitteln und uns dabei unterstĂŒtzen, fundierte Entscheidungen zu treffen.

Je sorgfĂ€ltiger wir diese Messwerte analysieren und interpretieren, desto prĂ€ziser werden unsere Schlussfolgerungen sein. Es ist eine effektive Möglichkeit, Muster zu erkennen, Trends zu verfolgen und mögliche Problemstellen zu identifizieren. Daher ist es ratsam, nicht nur die Werte selbst zu betrachten, sondern auch deren Kontext zu verstehen, um wirklich nĂŒtzliche Erkenntnisse zu gewinnen.


  1. "Mem Usage": 21,08 MB (8,23 %)

Speichernutzung (Memory Usage): Dies bezieht sich auf die Menge an Speicher, die von PHP-Funktionen und anderen Ressourcen wĂ€hrend des Ladevorgangs der Seite verwendet wird. Die "Speichernutzung" kann sich also auf den tatsĂ€chlichen Arbeitsspeicher (RAM) beziehen, den der Server oder der Browser benötigt, um die Website auszufĂŒhren.

  • Dieser Wert gibt die aktuelle Gesamtnutzung des Speichers fĂŒr die Website an, einschließlich sowohl der Dateien als auch der Datenbank. Dabei entsprechen des Beispiel die 8,23 % dem verfĂŒgbaren Speicherplatz von 256 MB. Dieser Wert berĂŒcksichtigt den Speicherplatz, der von der Datenbank fĂŒr die gespeicherten Daten verwendet wird.
  • Eine ausreichende Speichernutzung ist entscheidend fĂŒr die reibungslose Funktion der Website und stellt sicher, dass genĂŒgend Ressourcen vorhanden sind, um Inhalte und Daten effizient zu verwalten.

Bei einer hohen Speichernutzung kann es zu Leistungsproblemen kommen, wÀhrend eine optimierte Speicherverwendung die Ladegeschwindigkeit und die Benutzererfahrung verbessert.

"Speichernutzung" und "SeitengrĂ¶ĂŸe"

Die "Speichernutzung" ist nicht dasselbe wie die "SeitengrĂ¶ĂŸe". Die exakte Ermittlung der Page Size ist in der Praxis recht komplex, da verschiedene Faktoren wie Caching, ServerzustĂ€nde usw. berĂŒcksichtigt werden mĂŒssen. WĂ€hrend meiner Tests habe ich mit KI-Texter erfolgreich die HTML-GrĂ¶ĂŸe, CSS-Dateien und JavaScript-Dateien ermittelt.

Allerdings bin ich bei dem Versuch, die BildgrĂ¶ĂŸen zu berechnen, gescheitert, da die Webseite dadurch hĂ€ngenblieb und der Ladevorgang nicht abgeschlossen werden konnte.

Page Size
Die 'Page Size' kann jedoch mithilfe von Pingdom eingesehen werden. Sollte das Ergebnis (1) nicht wie erwartet angezeigt werden, da es anscheinend wÀhrend des Messzeitraums nicht vollstÀndig generiert wurde:

… dann klicke auf "Ergebnis teilen" (2). Die Ergebnisse sind dann per E-Mail abrufbar. Zum Beispiel:


 Die Webseite brauchte 1701 ms zum Laden, verwendete 159 Anfragen und belastete  7,9 MB . Die Google Page -Geschwindigkeitsleistung fĂŒr diese Webseite ist 83/100.


In diesem Beitrag WP: Caching unter der Lupe – Einblicke in die Unterschiede werfen wir einen genaueren Blick auf Caching, um die Unterschiede besser zu verstehen und wie sie sich auf die vollstĂ€ndige Ladegeschwindigkeit der Website auswirken:

Wer viel misst, misst viel Mist 😉

 

Query Monitor vs. WP Page Load Stats

Query Monitor ist eine leistungsfĂ€hige WordPress-Erweiterung, das fortgeschrittenen Webmasters detailliert AuskĂŒnfte ĂŒber ihre Website gibt. Es zeigt umfassende Diagnosedaten wie Abfragezeiten, Speichernutzung, PHP-Fehler und vieles mehr an, um die Website-Optimierung zu erleichtern.

Bemerkung zu den Leistungsmetriken: Vier Metriken sind dieselben wie die, die auch das Plug-in Query Monitor in der Headerzeile anzeigt. Diese Metriken sind die 'Abfragen' (Gesamtzahl der Datenabfragen) zusammen mit der Gesamtzeit der Datenabfragen, der DB-Abfrage und der verwendete Speicher, wenn auch in anderer Reihenfolge. Es ist jedoch auch möglich, dass die angezeigten Werte zwischen 'WP Page Load Stats' und 'Query Monitor' geringfĂŒgig variieren. Beide Plug-ins verwenden möglicherweise unterschiedliche Methoden, um die Website-Performance zu messen.

Anhaltspunkte zu
'WP Page Load Stats 9'

'WP Page Load Stats 9' (Interne Version): Es wĂ€re hier dann noch die 'Rendertime' und die 'Time To Interactive' im Angebot. Diese Werte ziehen fast gleich mit der 'Page Load Time', darum haben wir diese zusammen in separaten Programmierungscodes gepackt im Namen 'WP Page Load Stats 9', das ist also mit 9 Metriken. Anmkerkung: Die Kommastellen der beiden sind ĂŒber eine Millisecunde (1 Tausendstelsekunde: 0,001) hinaus auf vier erhöht, um meist ĂŒberhaupt eine Abweichung erkennen zu können. Das kann denn zum Ausprobieren mal ganz interessant sein.

9 Leistungsmetriken im Blick. OT: Wie die ZEIT vergeht –. Je Ă€lter man wird. Bild, Alexas_Fotos, Audio 'Alter Wecker' (old_alarm_clock_ticking) so 15 sec.

ErlÀuterung zu den 'Interen Verionen'

In der 'Internen Version' 'WP Page Load Stats 7' sowie in 'WP Page Load Stats 9' wurden die Funktionen zur Berechnung des Durchschnitts der Abfragezeiten in Sekunden aus dem ursprĂŒnglichen Plug-in entfernt, da wir sie als praktisch irrelevant erachteten. Ebenso wird die Anzeige der maximalen Speichernutzung nicht mehr dargestellt, da diese Information bereits aus den ProzentsĂ€tzen der direkten Nutzung abgeleitet werden kann.

Daher fĂŒhrt das Plug-in 'WP Page Load Stats 7' auch 'WP Page Load Stats 9' keine Datenbankinteraktionen durch, da die Funktion update_option() und Ă€hnliche Funktionen, die normalerweise Daten in der Datenbank speichern wĂŒrden, nicht mehr vorhanden sind. Die Messdaten werden stattdessen im laufenden Prozess in Variablen gespeichert und in Echtzeit im Frontend angezeigt, ohne in der Datenbank abgelegt zu werden.

Stattdessen wurde bei beiden 'Internen Versionen' die Gesamtzeit fĂŒr Datenbankabfragen hinzugefĂŒgt, was eine interessante Gegenbetrachtung zur Gesamtzahl der Datenabfragen darstellt. ZusĂ€tzlich wurden die Serverreaktion, die Serverantwort und die gesamte Seitenladezeit (Page Load Time) eingefĂŒhrt.

  • Die Version im Namen Inoffizielle Version hingegen wurde im Wesentlichen unverĂ€ndert beibehalten, jedoch so angepasst, dass sie auch unter PHP 8 einwandfrei funktioniert.

AbÀnderung der Texte und Optionen

Einstellungen wie Sprache und sonstiges sind nicht vorhanden. FĂŒr die individuelle Anpassung der Texte kann jeder Benutzer leicht die Datei wp-page-load-stats.php bearbeiten und die gewĂŒnschten Texte direkt in den li-Elementen festlegen. Diese Anpassungen können in der Datei unter dem Abschnitt [// Info anzeigen] vorgenommen werden. Das letzte li-Element mit der Klasse page-load-time erfordert eine separate Anpassung des Textes und des Dezimalzeichens, was im JavaScript-Code auch der Datei /wp-page-load-stats.php zu tun ist.

Anpassung des letzten li-Elements mit der Klasse 'page-load-time' in /wp-page-load-stats.php.
Anpassung des letzten li-Elements mit der Klasse 'page-load-time' in /wp-page-load-stats.php.
  • ZusĂ€tzliche Informationen zu den Optionen ist nach dem Code fĂŒr 'WP Page Load Stats 7' zu finden.

Hinweis: Die beiden Buttons "Schließen" und "Neuladen" haben hier ein leicht abweichendes Design und stehen nicht in Verbindung mit den in dieser Plug-in-Version vorgestellten Elementen. Die Anpassung dieser Buttons erfolgt in der style.css des Plug-ins.


Folgend sind die Programmierungs-Codes fĂŒr WP Page Load Stats 7, WP Page Load Stats 9 und WP Page Load Stats (Inoffizielle Version).

WP Page Load Stats 7 ab PHP 7+
(Interne Version, 7 Metriken)

7 Leistungsmetriken
7 Leistungsmetriken im Blick

Das ist die 'Interne Version' mit 7 Metriken von 'WP Page Load Stats' prĂ€sentiert. Diese Version ab PHP 7+ enthĂ€lt spezielle Anpassungen und Änderungen, die sie zu einer ausgezeichneten Option machen, um die Leistung deiner Website zu ĂŒberwachen.

WP Page Load Stats 7 Metriken (Interne Version)
/wp-page-load-stats.php


<?php
/*
Plugin Name: WP Page Load Stats 7 (Interne Version)
Plugin URI: https://wegerl.at/wp-page-load-stats-7/
Description: Zeigt 7 Leistungsmetriken im Footer an: Serverreaktionszeit, Gesamtzeit fĂŒr Datenbankabfragen, Gesamtzahl und Gesamtzeit der Datenabfragen, Serverarbeitungszeit (Serverantwort), Gesamtladezeit der Seite und Speichernutzung (Memory Usage).
Erfordert PHP 7.4
Version: 1.0.2
Author: Mike Jolley (Originalversion), [Ditmar Winkler] (Interne Version)
License: GPLv3
License URI: http://www.gnu.org/licenses/gpl-3.0.html
Author URI: http://mikejolley.com
Text Domain: wp-page-load-stats
Domain Path: /languages/
Note: Dies ist eine inoffizielle Version des WP Page Load Stats Plugins, bereitgestellt von [Ditmar Winkler].
*/
/**
 * WP_Page_Load_Stats Klasse
 */
class WP_Page_Load_Stats
{
    /**
     * Speichert den Namen der Option, in der Durchschnittswerte gespeichert werden.
     * @var string
     */
    private $average_option;

    /**
     * Initialisiert das Plugin
     */
    public function __construct()
    {
        add_action("init", [$this, "init"]);
        add_action("wp_head", [$this, "wp_head"]);
        add_action("wp_footer", [$this, "wp_footer"]);
        add_action("admin_head", [$this, "wp_head"]);
        add_action("admin_footer", [$this, "wp_footer"]);
        add_action("admin_enqueue_scripts", [$this, "enqueue"]);
        add_action("wp_enqueue_scripts", [$this, "enqueue"]);
    }

    /**
     * Initialisierungsfunktion.
     */
    public function init()
    {
        $this->average_option = is_admin()
            ? "wp_pls_admin_load_times"
            : "wp_pls_load_times";

        load_plugin_textdomain(
            "wp-page-load-stats",
            false,
            dirname(plugin_basename(__FILE__)) . "/languages/"
        );

        if (
            isset($_GET["reset_wp_pls_stats"]) &&
            $_GET["reset_wp_pls_stats"] == 1
        ) {
            delete_option($this->average_option);
            wp_safe_redirect(wp_get_referer());
            exit();
        }
    }
	
	/**
     * JavaScript-Code ausgeben.
     */
    public function output_js()
    {
        ?>
        <script type="text/javascript">
            function wp_pls_hide() {
                var wpplsDiv = document.getElementById('wp_pls');
                wpplsDiv.style.display = 'none';
            }
        </script>
        <?php
    }

    /**
     * wp_head Funktion.
     */
    public function wp_head()
    {
        echo "<script type='text/javascript'>
            function wp_pls_hide(){
               var wpplsDiv = document.getElementById('wp_pls');
               wpplsDiv.style.display = 'none';
            }
        </script>";
    }

    /**
     * wp_footer Funktion.
     */
    public function wp_footer()
    {
        $this->display();
        $this->output_js();
        $this->output_page_load_time_js();
    }
	
	/**
     * JavaScript-Code ausgeben fĂŒr die Berechnung der Page Load Time.
     */
    public function output_page_load_time_js()
    {
        ?>
        <script type="text/javascript">
            var wpplsStart = performance.now();
            window.addEventListener('load', function() {
                var wpplsDiv = document.getElementById('wp_pls');
                var wpplsEnd = performance.now();
                var wpplsTime = (wpplsEnd - wpplsStart) / 1000;
                var wpplsTimeRounded = Math.round(wpplsTime * 1000) / 1000;
                var pageLoadTime = wpplsTimeRounded.toFixed(3).toString().replace('.', ',');
                var pageLoadTimeElement = wpplsDiv.querySelector('.page-load-time');
                pageLoadTimeElement.textContent = 'Page Load Time: ' + pageLoadTime + ' sec.';
            });
        </script>
        <?php
    }

    /**
     * enqueue Funktion.
     */
    public function enqueue()
    {
        wp_enqueue_style("wp_pls-style", plugins_url("style.css", __FILE__));
    }

    /**
     * Anzeigefunktion.
     */
    public function display()
    {
        // Werte, die angezeigt werden sollen, abrufen
        $query_count = get_num_queries();
        $memory_usage = round(memory_get_usage() / 1024 / 1024, 2); // In MB umrechnen
        $memory_peak_usage = round(memory_get_peak_usage() / 1024 / 1024, 2); // In MB umrechnen
        $memory_limit = round(
            $this->let_to_num(WP_MEMORY_LIMIT) / 1024 / 1024,
            2
        ); // In MB umrechnen
        $load_times = array_filter(
            (array) get_option($this->average_option, [])
        );

        // Aktuelle Ladezeit abrufen
        $timer_stop = timer_stop(0);

        // Ladezeiten aktualisieren
        $load_times[] = $timer_stop;
        update_option($this->average_option, $load_times);

        // Aktuelle Datenbankabfragezeit abrufen
        global $wpdb;
        $db_query_time = 0;
        if (isset($wpdb->queries) && is_array($wpdb->queries)) {
            foreach ($wpdb->queries as $query) {
                $db_query_time += isset($query[1]) ? floatval($query[1]) : 0;
            }
        }

        // Serververarbeitungszeit fĂŒr die aktuelle Seite messen
        $server_response_time = floatval($this->get_server_response_time());

        // Gesamte Ladezeit der Seite abrufen (ohne Serverantwort)
        $total_load_time_without_response = $this->get_total_page_load_time_without_response();
        // Info anzeigen
        ?>
        <div id="wp_pls">
  <b>Leistungsmetriken im Blick</b>
  <ul>
    <li>
      <?php echo sprintf( __( 'Serverreaktion: %s sec.', 'wp-page-load-stats' ), number_format_i18n( $server_response_time, 3 ) ); ?>
    </li>
    <li>
      <?php printf( __( 'DB-Abfrage: %s sec.', 'wp-page-load-stats' ), number_format_i18n( $db_query_time, 3 ) ); ?>
    </li>
    <li>
      <?php echo sprintf( __( '%s Abfragen in %s sec.', 'wp-page-load-stats' ), $query_count, $timer_stop, 3 ); ?>
    </li>
    <li>
      <?php echo sprintf( __( 'Serverantwort: %s sec.', 'wp-page-load-stats' ), number_format_i18n( $total_load_time_without_response - $server_response_time, 3 ) ); ?>
    </li>
    <li class="page-load-time"></li>
    <hr style="border-color: #D2DBF4; margin: 5px 0; width: 100%;" />
    <li>
      <?php echo sprintf( __( 'Mem Usage: %s MB (%s).', 'wp-page-load-stats' ), str_replace('.', ',', $memory_usage), number_format( ( $memory_usage / $memory_limit ) * 100, 2, ',', '.' ) . '%' ); ?>
    </li>
  </ul>
            <div class="actions">
                <a onclick="wp_pls_hide()" href="javascript:void(0);">&times;</a>
                <a class="reset" href="<?php echo add_query_arg(
                    "reset_wp_pls_stats",
                    1
                ); ?>">-</a>
            </div>
        </div>
        <?php
    }

    /**
     * Serverreaktionszeit fĂŒr die aktuelle Seite messen.
     *
     * @return float Serverreaktionszeit in Sekunden.
     */
    private function get_server_response_time()
    {
        $start_time = microtime(true);

        // Dummy-Berechnung durchfĂŒhren, um die Serverreaktionszeit zu messen
        usleep(200000); // Hier wird eine Verzögerung von 200 Millisekunden (200000 Mikrosekunden) hinzugefĂŒgt

        $end_time = microtime(true);

        // Serverreaktionszeit in Sekunden berechnen
        $response_time = $end_time - $start_time;

        return $response_time;
    }

    /**
     * Gesamte Ladezeit der Seite abrufen (ohne Serverantwort).
     *
     * @return float Gesamte Ladezeit der Seite (ohne Serverantwort) in Sekunden.
     */
    private function get_total_page_load_time_without_response()
    {
        $start_time = $_SERVER["REQUEST_TIME_FLOAT"];

        // Warten, bis die Seite vollstÀndig geladen ist, und die gesamte Ladezeit der Seite (ohne Serverantwort) abrufen
        $total_load_time_without_response = microtime(true) - $start_time;

        return $total_load_time_without_response;
    }

    /**
     * Funktion zur Umwandlung der php.ini-Notation fĂŒr Zahlen (z. B. '2M') in eine Gleitkommazahl (float).
     *
     * @param string $size Die GrĂ¶ĂŸe im php.ini-Format, z. B. '2M', '64K', etc.
     * @return float Die umgewandelte GrĂ¶ĂŸe als Gleitkommazahl in Megabyte.
     */
    public function let_to_num($size)
    {
        $size = trim($size);
        $last = strtolower($size[strlen($size) - 1]);

        $size = (float) $size;
        switch ($last) {
            case "g":
                $size *= 1024;
            case "m":
                $size *= 1024;
            case "k":
                $size *= 1024;
        }

        return $size;
    }
}

$WP_Page_Load_Stats = new WP_Page_Load_Stats();
?>

Option: Anzeigenfeld nur im Frontend

Folgendes ist hier fĂŒr beide Versionen anwendbar. Wenn das Anzeigenfeld im Frontend fĂŒr Besucher, Administratoren und angemeldete Benutzer sichtbar sein soll, aber nicht im administrativen Bereich:

// Im administrativen Bereich (Dashboard) nicht anzeigen
    if (is_admin()) {
        return;
    }

Den obigen Code kopieren und in der Datei folgendem Bereich einfĂŒgen:

/**
 * Anzeigefunktion. / display function.
 */
public function display() {
    // Im administrativen Bereich (Dashboard) nicht anzeigen
    if (is_admin()) {
        return;
    }

    // Der Rest der Funktion bleibt unverÀndert
    // ...

Option: Anzeigenfeld nur fĂŒr Admin

Wenn das Anzeigenfeld nur fĂŒr den Administrator sichtbar sein soll und zusĂ€tzlich nur im Frontend, also auf der Website selbst, und nicht im Administrationsbereich:

// Nur fĂŒr den Administrator im Frontend anzeigen
    if (is_admin() || !current_user_can('administrator')) {
        return;
    }

Den obigen Code kopieren und in der Datei folgendem Bereich einfĂŒgen:

/**
 * Anzeigefunktion. / display function.
 */
public function display() {
    // Nur fĂŒr den Administrator im Frontend anzeigen
    if (is_admin() || !current_user_can('administrator')) {
        return;
    }

    // Der Rest der Funktion bleibt unverÀndert
    // ...

Option:
Dezimalzeichen von Komma zu Punkt

Im Anzeigenfled die Dezimalzeichen von Komma zu Punkt? Durch die Funktion number_format_i18n in WordPress ist eine internationale Formatierung fĂŒr Zahlen möglich. Das i18n in der Funktion steht fĂŒr 'Internationalization', was darauf hinweist, dass die Funktion speziell fĂŒr die Anpassung von Zahlen an verschiedene LĂ€ndereinstellungen und Sprachen entwickelt wurde.

Wenn du jedoch im Anzeigefeld das Dezimalzeichen statt Komma lieber als Punkt haben möchtest, dann ist nach // Info anzeigen folgendes auszutauschen:

<ul>
    <li><?php echo sprintf( __( '%s Abfragen in %s sec.', 'wp-page-load-stats' ), $query_count, str_replace( ',', '.', $timer_stop ) ); ?></li>
    <li><?php printf( __( 'DB-Abfrage: %s sec.', 'wp-page-load-stats' ), number_format( $db_query_time, 3, '.', '' ) ); ?></li>
    <li><?php echo sprintf( __( 'Speicher: %s MB (%s).', 'wp-page-load-stats' ), str_replace(',', '.', $memory_usage), number_format( ( $memory_usage / $memory_limit ) * 100, 2, '.', '' ) . '%' ); ?></li>
    <li><?php echo sprintf( __( 'Serverantwort: %s sec.', 'wp-page-load-stats' ), number_format( $server_response_time, 4, '.', '' ) ); ?></li>
    <li><?php echo sprintf( __( 'Serverarbeit: %s sec.', 'wp-page-load-stats' ), number_format( $total_load_time_without_response - $server_response_time, 3, '.', '' ) ); ?></li>
    <li class="page-load-time"></li> <!-- Dezimalzeichen und Text ist weiter unterhalb beim JavaScript-Code -->
</ul>

Folge des obigen Codes ist, dass das Element <li class="page-load-time"></li> Dezimalzeichen und Text unterhalb beim JavaScript-Code separat anzupassen sind. Das JavaScript ĂŒbermittelt das Dezimalzeichen und den Text ĂŒber die Class in das li-Element. Somit ist das Beispiel wie folgt anzupassen:

var pageLoadTime = wpplsTimeRounded.toFixed(3).toString().replace(',', '.');
                var pageLoadTimeElement = wpplsDiv.querySelector('.page-load-time');
                pageLoadTimeElement.textContent = 'Page Load Time: ' + pageLoadTime + ' sec.';

WP Page Load Stats 9 ab PHP 7+
(Interne Version, 9 Metriken)

9 Leistungsmetriken
9 Leistungsmetriken im Blick

Das ist die 'Interne Version' mit 9 Metriken von WP Page Load Stats prĂ€sentiert. Diese Version ab PHP 7+ enthĂ€lt spezielle Anpassungen und Änderungen, die sie zu einer ausgezeichneten Option machen, um die Leistung deiner Website zu ĂŒberwachen.

Der Unterschied zum WP Page Load Stats 7 liegt darin, dass die 'Rendertime' und die 'Time To Interactive' inkludiert sind. Da sich diese drei Messwerte sehr nahe beieinander befinden, haben wir hier vier Dezimalstellen festgelegt, um ĂŒberhaupt Unterschiede erkennen zu können. Dies kann hilfreich sein, um das Umfeld der 'Page Load Time' besser zu verstehen.

WP Page Load Stats 9 Metriken (Interne Version)
/wp-page-load-stats.php


<?php
/*
Plugin Name: WP Page Load Stats 9 (Interne Version)
Plugin URI: https://wegerl.at/wp-page-load-stats-7/
Description: Zeigt 7 Leistungsmetriken im Footer an: Serverreaktionszeit, Gesamtzeit fĂŒr Datenbankabfragen, Gesamtzahl und Gesamtzeit der Datenabfragen, Serverarbeitungszeit (Serverantwort), Rendertime, Time To Interactive, Gesamtladezeit der Seite und Speichernutzung (Memory Usage).
Erfordert PHP 7.4
Version: 1.0.2
Author: Mike Jolley (Originalversion), [Ditmar Winkler] (Interne Version)
Author URI: http://mikejolley.com
Text Domain: wp-page-load-stats
Domain Path: /languages/
Note: Dies ist eine inoffizielle Version des WP Page Load Stats Plugins, bereitgestellt von [Ditmar Winkler].
*/
/**
 * WP_Page_Load_Stats Klasse
 */
class WP_Page_Load_Stats
{
    /**
     * Speichert den Namen der Option, in der Durchschnittswerte gespeichert werden.
     * @var string
     */
    private $average_option;

    /**
     * Initialisiert das Plugin
     */
    public function __construct()
    {
        add_action("init", [$this, "init"]);
        add_action("wp_head", [$this, "wp_head"]);
        add_action("wp_footer", [$this, "wp_footer"]);
        add_action("admin_head", [$this, "wp_head"]);
        add_action("admin_footer", [$this, "wp_footer"]);
        add_action("admin_enqueue_scripts", [$this, "enqueue"]);
        add_action("wp_enqueue_scripts", [$this, "enqueue"]);
    }

    /**
     * Initialisierungsfunktion.
     */
    public function init()
    {
        $this->average_option = is_admin()
            ? "wp_pls_admin_load_times"
            : "wp_pls_load_times";

        load_plugin_textdomain(
            "wp-page-load-stats",
            false,
            dirname(plugin_basename(__FILE__)) . "/languages/"
        );

        if (
            isset($_GET["reset_wp_pls_stats"]) &&
            $_GET["reset_wp_pls_stats"] == 1
        ) {
            delete_option($this->average_option);
            wp_safe_redirect(wp_get_referer());
            exit();
        }
    }

    /**
     * wp_head Funktion.
     */
    public function wp_head()
    {
        echo "<script type='text/javascript'>
            function wp_pls_hide(){
               var wpplsDiv = document.getElementById('wp_pls');
               wpplsDiv.style.display = 'none';
            }
        </script>";
    }

    /**
     * wp_footer Funktion.
     */
    public function wp_footer()
    {
        $this->display();
        $this->output_js();
        $this->output_render_time_js();
        $this->output_tti_js();
        $this->output_page_load_time_js();
    }

    /**
     * JavaScript-Code ausgeben zur Messung der Rendertime.
     */
    public function output_render_time_js()
    {
        ?>
    <script type="text/javascript">
        var renderStartTime = performance.now();
        
        // Hier können Sie Ihre Webseite-Inhalte rendern lassen (z.B. durch das Laden von Bildern, CSS, JavaScript usw.)
        window.addEventListener('load', function() {
            var renderEndTime = performance.now();
            var renderTime = renderEndTime - renderStartTime;
            var renderTimeInSeconds = renderTime / 1000; // Umrechnung von Millisekunden in Sekunden
            var decimalSeparator = (1.1).toLocaleString().substring(1, 2); // Ermitteln des Dezimalzeichens

            var wpplsDiv = document.getElementById('wp_pls');
            var renderTimeElement = wpplsDiv.querySelector('.render-time');
            renderTimeElement.textContent = 'Rendertime: ' + renderTimeInSeconds.toLocaleString(undefined, { minimumFractionDigits: 4, maximumFractionDigits: 4 }).replace('.', decimalSeparator) + ' sec';
        });
    </script>
    <?php
    }

    /**
     * JavaScript-Code ausgeben zur Messung der Time To Interactive (TTI).
     */
    public function output_tti_js()
    {
        ?>
    <script type="text/javascript">
        var ttiStart = performance.now();

        // FĂŒgen Sie hier den Code ein, der die Seite interaktiv macht (z.B. das Laden von JavaScript, das Initialisieren von Interaktionselementen usw.)
        window.addEventListener('load', function() {
            var ttiEnd = performance.now();
            var ttiTime = ttiEnd - ttiStart;
            var decimalSeparator = (1.1).toLocaleString().substring(1, 2); // Ermitteln des Dezimalzeichens

            var wpplsDiv = document.getElementById('wp_pls');
            var ttiElement = wpplsDiv.querySelector('.tti');
            ttiElement.textContent = 'Time To Interac.: ' + (ttiTime / 1000).toLocaleString(undefined, { minimumFractionDigits: 4, maximumFractionDigits: 4 }).replace('.', decimalSeparator) + ' sec';
        });
    </script>
    <?php
    }

    /**
     * JavaScript-Code ausgeben fĂŒr die Berechnung der Page Load Time.
     */
    public function output_page_load_time_js()
    {
        ?>
        <script type="text/javascript">
    var wpplsStart = performance.now();
    window.addEventListener('load', function() {
        var wpplsDiv = document.getElementById('wp_pls');
        var wpplsEnd = performance.now();
        var wpplsTime = (wpplsEnd - wpplsStart) / 1000;
        
        // Formatierung der Dezimalstelle im JavaScript-Code
        var pageLoadTime = wpplsTime.toLocaleString(undefined, { minimumFractionDigits: 4, maximumFractionDigits: 4 }).replace('.', ',');
        
        var pageLoadTimeElement = wpplsDiv.querySelector('.page-load-time');
        pageLoadTimeElement.textContent = 'Page Load Time: ' + pageLoadTime + ' sec.';
    });
</script>
        <?php
    }

    /**
     * enqueue Funktion.
     */
    public function enqueue()
    {
        wp_enqueue_style("wp_pls-style", plugins_url("style.css", __FILE__));
    }

    /**
     * Anzeigefunktion.
     */
    public function display()
    {
        // Werte, die angezeigt werden sollen, abrufen
        $query_count = get_num_queries();
        $memory_usage = round(memory_get_usage() / 1024 / 1024, 2); // In MB umrechnen
        $memory_peak_usage = round(memory_get_peak_usage() / 1024 / 1024, 2); // In MB umrechnen
        $memory_limit = round(
            $this->let_to_num(WP_MEMORY_LIMIT) / 1024 / 1024,
            2
        ); // In MB umrechnen
        $load_times = array_filter(
            (array) get_option($this->average_option, [])
        );

        // Aktuelle Ladezeit abrufen
        $timer_stop = timer_stop(0);

        // Ladezeiten aktualisieren
        $load_times[] = $timer_stop;
        update_option($this->average_option, $load_times);

        // Aktuelle Datenbankabfragezeit abrufen
        global $wpdb;
        $db_query_time = 0;
        if (isset($wpdb->queries) && is_array($wpdb->queries)) {
            foreach ($wpdb->queries as $query) {
                $db_query_time += isset($query[1]) ? floatval($query[1]) : 0;
            }
        }

        // Serververarbeitungszeit fĂŒr die aktuelle Seite messen
        $server_response_time = floatval($this->get_server_response_time());

        // Gesamte Ladezeit der Seite abrufen (ohne Serverantwort)
        $total_load_time_without_response = $this->get_total_page_load_time_without_response();
        // Info anzeigen
        ?>
        <div id="wp_pls">
  <b>Leistungsmetriken im Blick</b>
  <ul>
    <li>
      <?php echo sprintf( __( 'Serverreaktion: %s sec.', 'wp-page-load-stats' ), number_format_i18n( $server_response_time, 3 ) ); ?>
    </li>
    <li>
      <?php printf( __( 'DB-Abfrage: %s sec.', 'wp-page-load-stats' ), number_format_i18n( $db_query_time, 3 ) ); ?>
    </li>
    <li>
      <?php echo sprintf( __( '%s Abfragen in %s sec.', 'wp-page-load-stats' ), $query_count, $timer_stop, 3 ); ?>
    </li>
    <li>
      <?php echo sprintf( __( 'Serverantwort: %s sec.', 'wp-page-load-stats' ), number_format_i18n( $total_load_time_without_response - $server_response_time, 3 ) ); ?>
    </li>
	<li class="render-time">Rendertime:</li>
    <li class="tti">Time To Interactive:</li>
    <li class="page-load-time"></li>
    <hr style="border-color: #D2DBF4; margin: 5px 0; width: 100%;" />
    <li>
      <?php echo sprintf( __( 'Mem Usage: %s MB (%s).', 'wp-page-load-stats' ), str_replace('.', ',', $memory_usage), number_format( ( $memory_usage / $memory_limit ) * 100, 2, ',', '.' ) . '%' ); ?>
    </li>
</ul>
            <div class="actions">
                <a onclick="wp_pls_hide()" href="javascript:void(0);">&times;</a>
                <a class="reset" href="<?php echo add_query_arg(
                    "reset_wp_pls_stats",
                    1
                ); ?>">-</a>
            </div>
        </div>
        <?php
    }

    /**
     * Serverantwortzeit fĂŒr die aktuelle Seite messen.
     *
     * @return float Serverantwortzeit in Sekunden.
     */
    private function get_server_response_time()
    {
        $start_time = microtime(true);

        // Dummy-Berechnung durchfĂŒhren, um die Serverantwortzeit zu messen
        usleep(200000); // Hier wird eine Verzögerung von 200 Millisekunden (200000 Mikrosekunden) hinzugefĂŒgt

        $end_time = microtime(true);

        // Serverantwortzeit in Sekunden berechnen
        $response_time = $end_time - $start_time;

        return $response_time;
    }

    /**
     * Gesamte Ladezeit der Seite abrufen (ohne Serverantwort).
     *
     * @return float Gesamte Ladezeit der Seite (ohne Serverantwort) in Sekunden.
     */
    private function get_total_page_load_time_without_response()
    {
        $start_time = $_SERVER["REQUEST_TIME_FLOAT"];

        // Warten, bis die Seite vollstÀndig geladen ist, und die gesamte Ladezeit der Seite (ohne Serverantwort) abrufen
        $total_load_time_without_response = microtime(true) - $start_time;

        return $total_load_time_without_response;
    }

    /**
     * Funktion zur Umwandlung der php.ini-Notation fĂŒr Zahlen (z. B. '2M') in eine Gleitkommazahl (float).
     *
     * @param string $size Die GrĂ¶ĂŸe im php.ini-Format, z. B. '2M', '64K', etc.
     * @return float Die umgewandelte GrĂ¶ĂŸe als Gleitkommazahl in Megabyte.
     */
    public function let_to_num($size)
    {
        $size = trim($size);
        $last = strtolower($size[strlen($size) - 1]);

        $size = (float) $size;
        switch ($last) {
            case "g":
                $size *= 1024;
            case "m":
                $size *= 1024;
            case "k":
                $size *= 1024;
        }

        return $size;
    }

    /**
     * JavaScript-Code ausgeben.
     */
    public function output_js()
    {
        ?>
        <script type="text/javascript">
            function wp_pls_hide() {
                var wpplsDiv = document.getElementById('wp_pls');
                wpplsDiv.style.display = 'none';
            }
        </script>
        <?php
    }
}

$WP_Page_Load_Stats = new WP_Page_Load_Stats();
?>

Und der Code fĂŒr das Dezimalzeichen als Punkt oder Komma individuell:

public function output_render_time_js($decimalSeparator = '.') {
        ?>
        <script type="text/javascript">
            var renderStartTime = performance.now();
            
            window.addEventListener('load', function() {
                var renderEndTime = performance.now();
                var renderTime = renderEndTime - renderStartTime;
                var renderTimeInSeconds = renderTime / 1000;

                var wpplsDiv = document.getElementById('wp_pls');
                var renderTimeElement = wpplsDiv.querySelector('.render-time');
                renderTimeElement.textContent = 'Rendertime: ' + renderTimeInSeconds.toFixed(6).replace(',', '.', '<?php echo $decimalSeparator; ?>') + ' sec';
            });
        </script>
        <?php
    }

    public function output_tti_js($decimalSeparator = '.') {
        ?>
        <script type="text/javascript">
            var ttiStart = performance.now();

            window.addEventListener('load', function() {
                var ttiEnd = performance.now();
                var ttiTime = ttiEnd - ttiStart;

                var wpplsDiv = document.getElementById('wp_pls');
                var ttiElement = wpplsDiv.querySelector('.tti');
                ttiElement.textContent = 'Time To Interactive: ' + (ttiTime / 1000).toFixed(6).replace(',', '.', '<?php echo $decimalSeparator; ?>') + ' sec';
            });
        </script>
        <?php
    }

WP Page Load Stats ab PHP 7+
(Inoffizielle Version)

ZusĂ€tzlich bieten wir auch die aktualisierte Version vom originĂ€r 'WP Page Load Stats' an, die speziell fĂŒr PHP 7.4+ optimiert ist und eine verbesserte Leistung bietet.

WP Page Load Stats (Inoffizielle Version)
/wp-page-load-stats.php


<?php
/*
Plugin Name: WP Page Load Stats (Inoffizielle Version)
Plugin URI originÀr: https://github.com/mikejolley/WP-Page-Load-Stats
Description: Display memory, page load time, average load time and query count in the footer. Requires PHP 7.4+
Version: 1.0.2
Author: Mike Jolley (Originalversion), [Ditmar Winkler] (Inoffizielle Version)
Author URI: http://mikejolley.com / [https://wegerl.at/wp-page-load-stats] (Inoffizielle Version)
Text Domain: wp-page-load-stats
Domain Path: /languages/
Note: Dies ist eine inoffizielle Version des WP Page Load Stats Plugins, die von [Ditmar Winkler] bereitgestellt wird. – FĂŒr offizielle UnterstĂŒtzung und Updates besuchen Sie bitte die GitHub-Seite des Autors Mike Jolley.
*/

/**
 * WP_Page_Load_Stats Class
 */
class WP_Page_Load_Stats {

    /**
     * Stores the name of the option where averages get saved.
     * @var string
     */
    private $average_option;

    /**
     * Gets things started
     */
    public function __construct() {
        add_action( 'init', array( $this, 'init' ) );
        add_action( 'wp_head', array( $this, 'wp_head' ) );
        add_action( 'wp_footer', array( $this, 'wp_footer' ) );
        add_action( 'admin_head', array( $this, 'wp_head' ) );
        add_action( 'admin_footer', array( $this, 'wp_footer' ) );
        add_action( 'admin_enqueue_scripts', array( $this, 'enqueue' ) );
        add_action( 'wp_enqueue_scripts', array( $this, 'enqueue' ) );
    }

    /**
     * init function.
     */
    public function init() {
        $this->average_option = is_admin() ? 'wp_pls_admin_load_times' : 'wp_pls_load_times';

        load_plugin_textdomain( 'wp-page-load-stats', false, dirname( plugin_basename( __FILE__ ) ) . '/languages/' );

        if ( isset( $_GET['reset_wp_pls_stats'] ) && $_GET['reset_wp_pls_stats'] == 1 ) {
            delete_option( $this->average_option );
            wp_safe_redirect( wp_get_referer() );
            exit;
        }
    }

    /**
     * wp_head function.
     */
    public function wp_head() {
        echo "<script type='text/javascript'>
            function wp_pls_hide(){
               var wpplsDiv = document.getElementById('wp_pls');
               wpplsDiv.style.display = 'none';
            }
        </script>";
    }

    /**
     * wp_footer function.
     */
    public function wp_footer() {
        $this->display();
        $this->output_js();
    }

    /**
     * enqueue function.
     */
    public function enqueue() {
        wp_enqueue_style( 'wp_pls-style', plugins_url('style.css', __FILE__) );
    }

    /**
     * display function.
     */
    public function display() {
        // Get values we're displaying
        $timer_stop         = timer_stop(0);
        $query_count        = get_num_queries();
        $memory_usage       = round( memory_get_usage() / 1024 / 1024, 2 ); // Convert to MB
        $memory_peak_usage  = round( memory_get_peak_usage() / 1024 / 1024, 2 ); // Convert to MB
        $memory_limit       = round( $this->let_to_num( WP_MEMORY_LIMIT ) / 1024 / 1024, 2 ); // Convert to MB
        $load_times         = array_filter( (array) get_option( $this->average_option, array() ) );
        $load_times[]       = $timer_stop;

        // Update load times
        update_option( $this->average_option, $load_times );

        // Get average
        if ( sizeof( $load_times ) > 0 ) {
            $average_load_time = round( array_sum( $load_times ) / sizeof( $load_times ), 4 );
        }

        // Display the info
        ?>
        <div id="wp_pls">
            <ul>
                <li><?php printf( __( '%s Abfragen in %s Secunden.', 'wp-page-load-stats' ), $query_count, $timer_stop ); ?></li>
                <li><?php printf( __( 'Im Mittel %s (%s Rd.).', 'wp-page-load-stats' ), $average_load_time, sizeof( $load_times ) ); ?></li>
                <li><?php printf( __( '%s von %s MB (%s) Verwendung.', 'wp-page-load-stats' ), $memory_usage, $memory_limit, round( ( $memory_usage / $memory_limit ), 2 ) * 100 . '%' ); ?></li>
                <li><?php printf( __( 'Max. Speichernutzung %s MB.', 'wp-page-load-stats' ), $memory_peak_usage ); ?></li>
            </ul>
            <div class="actions">
                <a onclick="wp_pls_hide()" href="javascript:void(0);">&times;</a>
                <a class="reset" href="<?php echo add_query_arg( 'reset_wp_pls_stats', 1 ); ?>">-</a>
            </div>
        </div>
        <?php
    }

    /**
     * let_to_num function.
     *
     * This function transforms the php.ini notation for numbers (like '2M') to an integer
     *
     * @param $size
     * @return int
     */
    public function let_to_num( $size ) {
        $l         = substr( $size, -1 );
        $ret       = substr( $size, 0, -1 );
        switch( strtoupper( $l ) ) {
            case 'P':
                $ret *= 1024;
            case 'T':
                $ret *= 1024;
            case 'G':
                $ret *= 1024;
            case 'M':
                $ret *= 1024;
            case 'K':
                $ret *= 1024;
        }
        return $ret;
    }

    /**
     * Output the JavaScript code.
     */
    public function output_js() {
        ?>
        <script type="text/javascript">
            function wp_pls_hide() {
                var wpplsDiv = document.getElementById('wp_pls');
                wpplsDiv.style.display = 'none';
            }
        </script>
        <?php
    }
}

$WP_Page_Load_Stats = new WP_Page_Load_Stats();

WP Page Load Stats: Das langersehnte Update!

Von Zahlen zur Erfahrung: Die wahre Performance

Wenn eine Webseite solide Leistungsmetriken aufweist und bereits verschiedene Optimierungsschritte unternommen wurden, ist es ratsam, sich vor allem auf die tatsĂ€chliche Benutzererfahrung zu fokussieren. Eine Webseite, die fĂŒr Besucher schnell lĂ€dt und eine gute Performance bietet, ist ein positiver Indikator, unabhĂ€ngig von den Ergebnissen unterschiedlicher Testdienste. Diese Dienste können zu verschiedenen Ergebnissen kommen, da sie jeweils unterschiedliche Parameter und Algorithmen verwenden.

Leistung im Blick,
Benutzererfahrung im Herzen.


Aktualisiert im Jahr 2023-November

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert