Einfaches Dumpen von Variablen, Arrays und Objekten

Jeder Entwickler kennt das lästige Dumpen von Variablen während des Debugging-Prozesses. Einfache Methoden wie echo 'Test: ' . $textvar . ' ' oder var_dump() gehören der Vergangenheit an. Heute stellen wir die DumpLogger-Klasse vor – eine elegante Lösung, um Logs in Dateien zu speichern und diese auf einfache Weise zu analysieren. Schluss mit unübersichtlichem und unstrukturierter Ausgabe! Mit dieser Klasse lassen sich Logs effizient speichern und sogar als HTML oder in reinem Text formatieren.

Wie funktioniert die DumpLogger Klasse?

Die DumpLogger-Klasse vereinfacht das Arbeiten mit Logs und bietet mehrere nützliche Funktionen:

add(): Fügt neue Log-Einträge hinzu, inklusive Timestamp und optionalem Titel.
writeToFile(): Schreibt die Log-Einträge in eine Datei. Optional kann das Format als HTML gesetzt werden, und es kann entschieden werden, ob die Datei überschrieben oder die Einträge angehängt werden sollen.
output(): Gibt die Log-Einträge direkt aus.
resetDump(): Setzt alle Logs zurück und löscht die Log-Datei.
getTotalTime(): Berechnet und gibt die Dauer der Logs in verschiedenen Zeiteinheiten wie Nanosekunden, Millisekunden, Sekunden oder Minuten aus.

Diese Methoden ermöglichen eine detaillierte, strukturierte und benutzerfreundliche Handhabung von Logs.

Anwendung: Initialisieren der Klasse

3.1 Custom PHP File

Um die Klasse zu nutzen, binden wir sie einfach in unser Projekt ein und initialisieren eine Instanz:

Copy to Clipboard

Mit Namespaces und als Container in Slim

In einem Slim Framework Projekt kann die Klasse als Service im Container registriert und genutzt werden. So geht’s:

1. Registrieren im Container:

Copy to Clipboard

2. Verwenden der Klasse:

Copy to Clipboard

Diese Methode ermöglicht es, die DumpLogger-Klasse in verschiedenen Teilen der Anwendung zu verwenden, ohne sie jedes Mal neu instanziieren zu müssen.

Beispiel

Dateistruktur

Copy to Clipboard

1. MiniClass.php

Eine kleine Beispielklasse, die wir loggen:

Copy to Clipboard

2. demo.php

Copy to Clipboard

3. Workflow für das Demo-Skript

Initialisierung der DumpLogger-Klasse:
- Der DumpLogger wird mit einem Log-Ordner (/logs) und einem Log-Dateinamen (demo-log.txt) initialisiert.
- Tipp: Falls die Datei nicht korrekt geschrieben wird, überprüfe Folgendes:
  - Pfad: Stelle sicher, dass der angegebene Pfad existiert oder erstellt werden kann.
  - Berechtigungen: Der PHP-Prozess benötigt Schreibrechte für den Ordner.
Loggen eines Arrays:
- Ein Beispiel-Array ['item1' => 'value1', 'item2' => 'value2', 'item3' => 'value3'] wird geloggt.
- Es wird ein Titel (Array-Demo) hinzugefügt, um den Eintrag in der Log-Datei und der HTML-Ausgabe leicht identifizierbar zu machen.
Erstellen und Loggen einer Klasse (MiniClass):
- Eine Instanz der Klasse MiniClass wird erstellt.
- Die Methode getInfo() liefert Informationen über die Instanz als Array (z. B. ['name' => 'TestName', 'value' => 12345]).
- Diese Daten werden mit einem Titel (MiniClass-Info) geloggt.
Speichern der Logs in einer Datei:
- Mit der Methode writeToFile() werden alle bisher gesammelten Logs in die Datei demo-log.txt geschrieben.
- Falls Probleme auftreten:
  - Überprüfe den Wert von $logFolder und $logFile. Der Log-Ordner sollte existieren oder vom Skript erstellt werden können.
  - Prüfe, ob die Datei demo-log.txt bereits geöffnet ist (z. B. in einem anderen Programm), da dies zu Schreibfehlern führen kann.
  - Verwende error_log() oder Debugging-Ausgaben, um den Schreibprozess zu überwachen.
HTML-Ausgabe der Logs:
- Die Methode output() gibt die Logs direkt als HTML aus, ideal für die Anzeige im Browser. Die Struktur ist so gestaltet, dass sie klar und gut lesbar ist:
  - Zeitstempel
  - Titel
  - Inhalt (z. B. Arrays oder Objekte, formatiert mit print_r())
Zurücksetzen der Logs:
- Nach dem Schreiben und Ausgeben werden die Logs mit resetDump() zurückgesetzt.
- Dies löscht die gespeicherten Einträge und entfernt ggf. die Log-Datei.

4. Wichtige Hinweise für die Fehlerbehebung

Log-Ordner überprüfen:

- Existiert der Ordner? Wenn nicht, erstellt DumpLogger ihn automatisch, sofern die Berechtigungen ausreichen.
- Wenn es Probleme gibt, überprüfe, ob der PHP-Prozess Schreibzugriff auf den Zielordner hat.

Pfad zur Log-Datei prüfen:

- Verwende var_dump() oder error_log() in der Methode getFilename() der DumpLogger-Klasse, um sicherzustellen, dass der generierte Pfad korrekt ist.

Beispiel:

Copy to Clipboard

Fehler beim Schreiben in die Datei:

Nutze try-catch, um Ausnahmen abzufangen, wie in der writeToFile()-Methode:

Copy to Clipboard

Erweiterte Prüfung bei Problemen

Falls der Code nicht wie erwartet funktioniert:

Log-Ordner manuell prüfen:
- Schaue nach, ob der Ordner erstellt wurde und ob dort die Datei demo-log.txt existiert.
PHP-Berechtigungen prüfen:
- Falls der Webserver (z. B. Apache oder Nginx) verwendet wird, stelle sicher, dass der Benutzer (z. B. www-data oder apache) Schreibzugriff hat.
- Unter Linux kannst du die Berechtigungen anpassen: chmod -R 0777 /pfad/zum/log-folder
- Hinweis: Für Entwicklungszwecke ist 0777 akzeptabel, für Produktionssysteme jedoch unsicher.

4. Ausgabe

Beispiel-HTML-Ausgabe:

Copy to Clipboard

Log-Datei (demo-log.txt):

Copy to Clipboard

Das Setup zeigt, wie man Arrays und Klassen einfach mit der DumpLogger-Klasse loggen und ausgeben kann! 😊.

Quellcode

Copy to Clipboard

<?php

namespace yourNamespace;

/**
 * DumpLogger-Klasse zum Loggen und Ausgeben von Variablen, Arrays und Objekten in eine Datei oder HTML-Ausgabe.
 * 
 * Diese Klasse hilft dabei, logische Daten während der Entwicklung zu dumpen und in eine Log-Datei zu schreiben.
 * Sie bietet eine zeitlich gestaffelte Ausgabe und kann die Log-Daten in Text oder HTML speichern.
 *
 * @package DumpLogger
 * @author Johannes Teitge <johannes@teitge.de>
 * @license MIT-Lizenz: 
 * Es wird hiermit kostenlos jedem, der eine Kopie dieser Software und der zugehörigen
 * Dokumentationsdateien (die "Software") erhält, die Erlaubnis erteilt, mit der Software
 * uneingeschränkt zu verfahren, einschließlich ohne Einschränkung der Rechte, die Software
 * zu nutzen, zu kopieren, zu ändern, zu fusionieren, zu veröffentlichen, zu verteilen,
 * Unterlizenzen zu erteilen und/oder Kopien der Software zu verkaufen und Personen, denen
 * die Software zur Verfügung gestellt wird, diese Rechte zu gewähren, mit der folgenden
 * Bedingung:
 * 
 * Der oben stehende Copyright-Vermerk und dieser Berechtigungsvermerk müssen in allen
 * Kopien oder wesentlichen Teilen der Software enthalten sein.
 * 
 * @link https://www.teitge.de
 * @version 1.0.0
 * @date	 2025-01-19	
 */

class DumpLogger
{
    private $entries = [];  // Speichert die Log-Einträge
    private $logFolder;     // Ordner, in dem die Log-Datei gespeichert wird
    private $logFilename;   // Standard-Log-Dateiname
    private $customLogFilename;  // Benutzerdefinierter Log-Dateiname
    private $maxEntries = 100;  // Maximale Anzahl der Log-Einträge
    private $startTime = null;  // Startzeit für den Timer
    private $endTime = null;    // Endzeit für den Timer
    private $timerStopped = false;  // Flag, ob der Timer gestoppt wurde

/**
     * Konstruktor, um die Log-Ordner und -Datei zu definieren.
     * 
     * @param string $logFolder Der Ordner, in dem die Log-Datei gespeichert wird
     * @param string $logFile Der Log-Dateiname
     * @throws \RuntimeException Wenn der Ordner nicht erstellt werden kann
     */
    public function __construct(string $logFolder, string $logFile)
    {
        // Überprüfen, ob der Log-Ordner existiert und erstellen, wenn er nicht existiert
        if (!is_dir($logFolder)) {
            if (!mkdir($logFolder, 0777, true) && !is_dir($logFolder)) {
                throw new \RuntimeException("Log-Ordner konnte nicht erstellt werden: $logFolder");
            }
        }

// Setzen der Log-Ordner und Dateinamen
        $this->logFolder = rtrim($logFolder, DIRECTORY_SEPARATOR);
        $this->logFilename = $logFile;
        $this->customLogFilename = '';
        $this->startTime = null;
        $this->endTime = null;
    }

/**
     * Ändert den Dateinamen für die Logs.
     * 
     * @param string $fileName Der benutzerdefinierte Log-Dateiname
     */
    public function setFilename(string $fileName): void
    {
        $this->customLogFilename = $fileName;
    }

/**
     * Fügt einen Eintrag zum Log hinzu.
     * 
     * @param mixed $content Der Inhalt, der geloggt werden soll
     * @param string $title Optionaler Titel des Log-Eintrags
     */
    public function add($content, string $title = ''): void
    {
        // Timer automatisch starten, wenn dies der erste Eintrag ist
        if (empty($this->entries) && $this->startTime === null) {
            $this->startTimer();
        }

// Hinzufügen des Eintrags zur Log-Liste
        $this->entries[] = [
            'timestamp' => date('Y-m-d H:i:s'),
            'title' => $title,
            'content' => $content,
        ];

// Optional: Beschränkung auf maxEntries
        if (count($this->entries) > $this->maxEntries) {
            array_shift($this->entries);
        }
    }

/**
     * Schreibt alle gespeicherten Log-Einträge in die Log-Datei.
     * 
     * @param bool $showTime Optional, ob die Gesamtdauer der Logs ausgegeben werden soll
     * @param bool $appendData Optional, ob die Daten angehängt oder die Datei überschrieben werden soll
     * @param bool $isHtml Optional, ob das Format der Log-Datei HTML sein soll
     */
    public function writeToFile(bool $showTime = true, bool $appendData = true, bool $isHtml = false): void
    {
        // Wenn keine Einträge vorhanden sind, nichts tun
        if (empty($this->entries)) {
            return;
        }

// Timer automatisch stoppen, falls noch nicht geschehen
        $this->endTimerIfNeeded();

try {
            $filename = $this->getFilename();
			
			echo $filename;

// Wenn das HTML-Format aktiviert ist, HTML-Ausgabe erstellen
 if ($isHtml) {
 $output = "<html><head><title>Logfile</title></head><body>";
 $output .= "<h1>Log-Daten</h1>";
 $output .= "<ul>";
 foreach ($this->entries as $entry) {
 $timestamp = $entry['timestamp'];
 $title = $entry['title'] !== '' ? "" . htmlspecialchars($entry['title']) . "" : '';
 $content = nl2br(print_r($entry['content'], true)); // Für bessere Darstellung von Arrays/Objekten
 $output .= "<li>{$timestamp} {$title} {$content}</li>";
 }
 $output .= "</ul>";

// Gesamtdauer als HTML
 if ($showTime) {
 $output .= "Dump abgeschlossen. Gesamtdauer: " . $this->getTotalTime() . " Sekunden";
 }

$output .= "</body></html>";
 } else {
 // Normale Textausgabe
 $output = implode("\n\n", array_map(function ($entry) {
 $timestamp = $entry['timestamp'];
 $title = $entry['title'] !== '' ? "### " . $entry['title'] . " ###" : '';
 return "[{$timestamp}]\n" . $title . "\n" . print_r($entry['content'], true);
 }, $this->entries));

if ($showTime) {
                    $output .= "\n### Dump abgeschlossen. Gesamtdauer: " . $this->getTotalTime() . " Sekunden ###\n";
                }
            }

// Je nach Parameter appendData entweder anfügen oder überschreiben
            $fileMode = $appendData ? FILE_APPEND : 0;

// In die Log-Datei schreiben
            file_put_contents($filename, $output, $fileMode);

// Einträge zurücksetzen, nachdem sie in die Datei geschrieben wurden
          //  $this->entries = [];
        } catch (\Exception $e) {
            error_log("Fehler beim Schreiben in die Log-Datei: " . $e->getMessage());
        }
    }

/**
     * Gibt die Log-Einträge aus.
     */
    public function output(): void
    {
        if (empty($this->entries)) {
            return;
        }

// Timer automatisch stoppen, falls noch nicht geschehen
        $this->endTimerIfNeeded();

foreach ($this->entries as $entry) {
 echo "<pre>[{$entry['timestamp']}]\n";
 if ($entry['title'] !== '') {
 echo "### {$entry['title']} ###\n";
 }
 print_r($entry['content']);
 echo "</pre>";
 }

// Einträge zurücksetzen, nachdem sie ausgegeben wurden
      //  $this->entries = [];
    }

/**
     * Setzt die Log-Daten, Timer und Flags zurück.
     */
    public function resetDump(): void
    {
        $this->entries = [];
        $this->startTime = null;
        $this->endTime = null;
        $this->timerStopped = false;
    }

/**
     * Private Methode zum Starten des Timers.
     */
    private function startTimer(): void
    {
        if ($this->startTime === null) {
            $this->timerStopped = false;
            $this->startTime = microtime(true); // Setze die Startzeit
        }
    }

/**
     * Private Methode zum Stoppen des Timers.
     */
    private function endTimer(): void
    {
        if ($this->startTime !== null && $this->endTime === null) {
            $this->endTime = microtime(true); // Setze die Endzeit
            $this->timerStopped = true;
        }
    }

/**
     * Private Methode zum Stoppen des Timers, falls noch nicht gestoppt.
     */
    private function endTimerIfNeeded(): void
    {
        if (!$this->timerStopped) {
            $this->endTimer();
        }
    }

/**
     * Berechnet die Gesamtdauer der Logs und gibt sie in der passenden Einheit aus.
     */
    private function getTotalTime(): ?string
    {
        if ($this->startTime === null || $this->endTime === null) {
            return null;
        }

// Berechnung der Zeitdifferenz in Sekunden mit höchster Genauigkeit
        $timeInSeconds = $this->endTime - $this->startTime;

// Wenn die Zeit in Sekunden weniger als eine Millisekunde beträgt
 if ($timeInSeconds < 0.000001) {
 $time = round($timeInSeconds * 1000000000, 2) . " ns"; // Nanosekunden
 }
 // Wenn die Zeit zwischen 1 Millisekunde und 1 Sekunde liegt
 elseif ($timeInSeconds < 1) {
 $time = round($timeInSeconds * 1000, 4) . " ms"; // Millisekunden
 }
 // Wenn die Zeit zwischen 1 Sekunde und 1 Minute liegt
 elseif ($timeInSeconds < 60) {
 $time = round($timeInSeconds, 2) . " s"; // Sekunden
 }
 // Wenn die Zeit größer als 1 Minute ist
 else {
 $time = round($timeInSeconds / 60, 2) . " min"; // Minuten
 }

return $time;
    }

/**
     * Gibt den vollständigen Pfad zur Log-Datei zurück.
     */
    private function getFilename(): string
    {
        return $this->logFolder . DIRECTORY_SEPARATOR . ($this->customLogFilename ?: $this->logFilename);
    }
}

Fazit 🏁

Mit der DumpLogger-Klasse wird das Debugging und Logging in PHP-Projekten deutlich vereinfacht. Egal, ob für kleinere Projekte oder größere Anwendungen, diese Klasse bietet eine effiziente Möglichkeit, Logs zu verwalten und zu speichern. Sie stellt nicht nur die Log-Daten auf eine klare und strukturierte Weise zur Verfügung, sondern bietet auch die Flexibilität, die Daten in verschiedenen Formaten (z.B. HTML) zu exportieren.

Die DumpLogger-Klasse: Einfaches Loggen von Variablen, Arrays und Objekten

Die DumpLogger-Klasse: Einfaches Loggen von Variablen, Arrays und Objekten

Zurück zur Übersicht…

Wie funktioniert die DumpLogger Klasse?

Anwendung: Initialisieren der Klasse

3.1 Custom PHP File

Mit Namespaces und als Container in Slim

Beispiel

Dateistruktur

1. MiniClass.php

2. demo.php

3. Workflow für das Demo-Skript

4. Wichtige Hinweise für die Fehlerbehebung

Log-Ordner überprüfen:

Pfad zur Log-Datei prüfen:

Fehler beim Schreiben in die Datei:

Erweiterte Prüfung bei Problemen

4. Ausgabe

Beispiel-HTML-Ausgabe:

Log-Datei (demo-log.txt):

Quellcode

Fazit 🏁

Leave A Comment Antworten abbrechen

Was dir noch gefallen könnte

Fernwartung mit Zwei Monitoren: Gratis mit Chrome Remote Desktop und AnyViewer

Ratz Fatz Mailer – ein Kontaktformular auf die Schnelle 🚀

Doppelten Mailversand in Formidable Forms verhindern

Lebe kreativ, denke positiv und genieße die kleinen Dinge

Menü

Aktuelles

🔧 JsonSQL Update – April 2025

JsonSQL

Skype ist Geschichte – welche Alternativen jetzt wirklich überzeugen

Social Links