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