Info echo

Ist der Classic-Editor schon zu kennen? –

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

---

Info echo

Anklickt Classic-Editor mit Advanced Editor Tools

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

---

Info echo

Klassischen Editor anwenden! – und …

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

---

Info echo

… 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

Advanced Editor Tools aktive Installationen: 2+ Millionen

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

---

Info echo

Ansprechend! – so gehts hier zur Lancierung

"Advanced Editor Tools – ist de luxe!"
Anklickt! – Advanced Editor Tools; und NEU! – Classic Widgets

---

Info echo

… und NEU! – Classic Widgets

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

---

Info echo

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.

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.

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.

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. 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:

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.

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.

• 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)

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)

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