Logger

1. Einleitung

Die Klasse Logger ist ein Tool, mit dem Applikationsinformationen einfach und zentral aufgenommen werden können. Er unterstützt die Ausgabe in mehrere Log-Dateien, die Definition von Prioritäten (log severity) pro Eintrag und die Konfiguration von Schwellwerten. Letztere dienen vor allem dazu, im Produktionsbetrieb nicht benötigte Debug- oder Trace-Ausgabe auszublenden.

Die Definition von Schwellwerten wurde im Release 1.15 eingeführt und kann erst ab dieser Version verwendet werden.

Um die Performance einer Anwendung nicht durch häufige, verteilte und konkurrierende File-Zugriffe zu beeinträchtigen, muss der Logger als Singleton-Instanz erzeugt und verwendet. Die Logfile-Einträge werden dann am Ende eines Requests gesammelt in das entsprechende Logfile geschrieben.

2. Architektur

Ab Version 1.17 sieht die Logger-Implementierung des APF eine Trennung zwischen dem Logger selbst, der Beschreibung eines Log-Eintrags (LogEntry) und der Persistenz (LogWriter) vor:

Architektur des APF Loggers ab Version 1.17

Der Logger stellt dabei die zentrale Anlaufstelle für das Framework und darauf aufsetzenden Applikationen dar, Log-Einträge zu schreiben. Das Aussehen eines Log-Eintrags wird durch das Interface LogEntry und die Referenz-Implementierung SimpleLogEntry beschrieben. Wohin ein Eintrag letztlich geschrieben wird, regelt die Implementierung des LogWriter-Interfaces. Diese nutzt der Logger um am Ende der Request-Verarbeitung die Inhalte des Puffers zu persistieren.

Zur Registrierung von LogWriter-Implementierungen stellt der Logger die Methoden

  • addLogWriter($target, LogWriter $writer)
  • removeLogWriter($target)
  • getLogWriter($target)

zur Verfügung. Dabei wird jeder LogWriter mit einem eindeutigen Bezeichner ($target) registriert. Der Logger nutzt das Ziel um die eingehenden Log-Einträge der jeweils gewünschten Persistenz-Schicht zuzuordnen. Für dieses Mapping wird dem LogEntry ebenso ein Ziel zugeordnet.

Das Interface eines LogEntry gestaltet sich wie folgt:

PHP-Code
interface LogEntry { const SEVERITY_TRACE = 'TRACE'; const SEVERITY_DEBUG = 'DEBUG'; const SEVERITY_INFO = 'INFO'; const SEVERITY_WARNING = 'WARN'; const SEVERITY_ERROR = 'ERROR'; const SEVERITY_FATAL = 'FATAL'; public function __toString(); public function getLogTarget(); public function getSeverity(); }

Die Methoden getSeverity() nutzt der Logger um zu entscheiden, ob ein Eintrag über dem definierten Schwellwert liegt oder verworfen werden soll. Mit dem Rückgabewert der Funktion getLogTarget() weist der Logger den Eintrag dem entsprechenden LogWriter zu.

Die Implementierung eines LogWriters muss folgendes Interface erfüllen:

PHP-Code
interface LogWriter { public function writeLogEntries(array $entries); public function setTarget($target); }

Mit Hilfe der Methode setTarget() injiziert der Logger den Ziel-Bezeichner. Dieser kann dann von der Implementierung beispielsweise für die Generierung eines Log-Datei-Namens genutzt werden. Die Methode writeLogEntries() ist für die Persistenz der übergebenen Liste von Einträgen zuständig.

Im Vergleich zur Implementierung des Loggers bis einschließlich Version 1.16 kann an Version 1.17 der volle Funktionsumfang des bei gleichzeitig flexiblerer Konfiguration genutzt werden. Neben der Konfiguration von unterschiedlichen Persistenz-Möglichkeiten können Sie nun auch das Format von Log-Einträgen über eigene LogEntry-Implementierungen definieren.

3. Konfiguration

3.1. Verwalten von LogWritern

Der Logger selbst ist wie in Kapitel 2 beschrieben ein Router für Log-Einträge, der die Persistenz an registrierte LogWriter delegiert. Damit ein Eintrag auch den Weg in eine Log-Datei oder eine Datenbank findet, muss ein persistiert werden kann braucht es einen LogWriter.

Zur Verwaltung von LogWritern bietet der Logger die in den folgenden Kapitel beschriebenen Möglichkeiten.

Wurde kein Log-Ziel definiert, quittiert der Logger das Schreiben der Einträge mit einer Exception. Diese hat beispielsweise folgenden Inhalt:
Code
Fatal error: Uncaught exception 'LoggerException' with message 'Log writer with name "mysqlx" is not registered!' in */core/logging/Logger.php on line 433
Der Logger implementiert aus Sicherheitsgründen kein Fallback-Szenario, da ein solches zur Ausgabe von sensiblen Informationen an die Aussenwelt führen kann (z.B. bei Fallback auf den StdOutLogWriter).
3.1.1. Hinzufügen von LogWritern

Im Auslieferungszustand des APF wird standardmäßig der FileLogWriter mit dem Bezeichner, der im Registry-Schlüssel InternalLogTarget (Namespace: APF\core) definiert ist (Standard: apf), registriert.

Beabsichtigen Sie eigene LogWriter hinzuzufügen, so können Sie die Methode addLogWriter() nutzen. Dies gilt sowohl für mitgelieferte als auch eigene Implementierungen:

PHP-Code
use APF\core\singleton\Singleton; use APF\core\logging\Logger; $logger = &Singleton::getInstance('APF\core\logging\Logger'); use APF\core\logging\writer\StdOutLogWriter; $logger->addLogWriter( 'stdout', new StdOutLogWriter() );

Anschließend kann der mit stdout registrierte LogWriter wie folgt genutzt werden:

PHP-Code
use APF\core\singleton\Singleton; use APF\core\logging\Logger; use APF\core\logging\SimpleLogEntry; $logger = &Singleton::getInstance('APF\core\logging\Logger'); $logger->addEntry(new SimpleLogEntry( 'stdout', 'This is a log message', LogEntry::SEVERITY_INFO ));
3.1.2. Konfiguration von bestehenden LogWritern

Möchten Sie einen bereits registrierten LogWriter konfigurieren, so können Sie dazu die Methode getLogWriter() nutzen. Welche Persistenz-Schichten aktuell registriert sind, können Sie per getRegisteredTargets() abfragen.

Möchten Sie die Konfiguration des Standard-LogWriters verändern, so nutzen Sie bitte folgenden Code-Block als Vorlage:

PHP-Code
$standardWriter = $logger->getLogWriter( Registry::retrieve('APF\core', 'InternalLogTarget') ); $standardWriter->setHostPrefix($_SERVER['HTTP_HOST']);

Details zur Konfiguration von LogWritern entnehmen Sie bitte Kapitel 4.

3.1.3. Erweiterung der Konfiguration mit bestehenden LogWritern

Mit Hilfe der Methode getLogWriter() ist es möglich, bestehende bzw. bereits registrierte LogWriter als Basis für eigene Ziele zu nutzen. Nutzen Sie bitte folgenden Code-Block um den im Auslieferungszustand registrierten LogWriter unter einem anderen Ziel zu registrieren:

PHP-Code
$writer = clone $logger->getLogWriter( Registry::retrieve('APF\core', 'InternalLogTarget') ); $logger->addLogWriter('new-target', $writer);

Wie in den vorangegangenen Kapitel beschrieben können Sie den geklonten LogWriter natürlich wie gewünscht konfigurieren.

3.1.4. Löschen von registrierten LogWritern

Um vorhandene LogWriter zu entfernen nutzen Sie bitte die Methode removeLogWriter():

PHP-Code
$logger->removeLogWriter('mysqlx');

Bitte beachten Sie, dass bereits vorhandene Log-Einträge dann nicht mehr persistiert werden können.

3.1.5. Konfiguration für Entwicklungsumgebungen

In Entwicklungsumgebungen kann es notwendig sein, alle vorhandenen Log-Einträge direkt mit dem Quelltext der Applikation auszugeben. Um alle vorhandenen LogWriter auf die Standard-Ausgabe des Webservers umzulenken, nutzen Sie bitte folgenden Quellcode:

PHP-Code
foreach($logger->getRegisteredTargets() as $logTarget) { $logger->addLogWriter($logTarget, new StdOutLogWriter()); }

3.3. Puffer-Länge

Wie bereits in der Einleitung angesprochen, sammelt der Logger zunächst alle Einträge und persistiert diese erst am Ende des Requests. Bei hohem Log-Aufkommen kann es daher zu hohem Speicherverbrauch der Applikation kommen, die mit den System-Einstellungen von PHP kollidiert (z.B. memory_limit).

Um den Speicherverbrauch zu reduzieren bzw. zu restringieren kann die maximale Puffer-Länge definiert werden. Der Standardwert ist 300, kann jedoch jederzeit durch

PHP-Code
use APF\core\singleton\Singleton; use APF\core\logging\Logger; $logger = &Singleton::getInstance('APF\core\logging\Logger'); $logger->setMaxBufferLength(500);

adaptiert werden.

3.4. Schwellwert

Mit dem Release 1.15 ist es möglich, Schwellwerte bzw. Profile für Log-Einträge zu definieren. Liegt ein Eintrag mit einer definierten severity oberhalb des definierten Schwellwertes bzw. innerhalb des gewählten Profils, so wird der Eintrag in die Log-Datei geschrieben. Falls dies nicht zutrifft, wird er verworfen.

Um den Schwellwert zu definieren, können Sie folgenden Code nutzen:

PHP-Code
use APF\core\singleton\Singleton; use APF\core\logging\Logger; $logger = &Singleton::getInstance('APF\core\logging\Logger'); $logger->setLogThreshold(Logger::$LOGGER_THRESHOLD_WARN);

Wie dem Beispiel zu entnehmen ist, definiert der Logger bereits eine Auswahl an Standard-Schwellwerten bzw. -Profilen. Darüber hinaus können Sie beliebige eigene Profile erstellen. Hierzu nutzen Sie bitte die severity-Definitionen des Interfaces LogEntry. Diese sind:

  • SEVERITY_TRACE
  • SEVERITY_DEBUG
  • SEVERITY_INFO
  • SEVERITY_WARNING
  • SEVERITY_ERROR
  • SEVERITY_FATAL

Der folgende Code-Block zeigt ein Beispiel, in dem nur INFO- und TRACE-Einträge in die Log-Datei geschrieben werden:

PHP-Code
use APF\core\singleton\Singleton; use APF\core\logging\Logger; $logger = &Singleton::getInstance('APF\core\logging\Logger'); $logger->setLogThreshold(array( LogEntry::SEVERITY_TRACE, LogEntry::SEVERITY_INFO ));
Bitte beachten Sie, dass die mit der Methode setLogThreshold() definierten Schwellwerte nicht an eine Hierarchie gebunden sind. Sie können daher frei definieren, welche Einträge geschrieben und welche verworfen werden.

Der Logger definiert folgende Standard-Schwellwerte:

  • $LOGGER_THRESHOLD_ALL
  • $LOGGER_THRESHOLD_WARN
  • $LOGGER_THRESHOLD_INFO
  • $LOGGER_THRESHOLD_ERROR

Details zur Definition entnehmen Sie bitte der API-Dokumentation.

4. Vorhandene LogWriter

Mit der Version 1.17 des APF werden die in den folgenden Kapiteln beschriebenen LogWriter-Implementierungen mitgeliefert.

4.1. FileLogWriter

Der FileLogWriter schreibt die übergebenen Log-Einträge in eine Datei. Der Name der Datei setzt sich dabei aus dem aktuellen Datum, einem optionalen Host-Präfix und dem Log-Ziel für das der LogWriter konfiguriert wurde zusammen (Beispiel: 2013_01_20__127_0_0_1__apf.log).

Die folgenden Kapitel beschreiben die Konfiguration des FileLogWriters.

4.1.1. Log-Verzeichnis

Zur Konfiguration des Log-Verzeichnisses nutzen Sie bitte den Konstruktor (verpflichtend) oder die Methode setLogDir() (optional). Die Registrierung des FileLogWriters kann wie folgt vorgenommen werden:

PHP-Code
use APF\core\logging\writer\FileLogWriter; $logger->addLogWriter('file', new FileLogWriter('/path/to/log/dir'));

Die Konfiguration von bestehenden Instanzen lässt sich wie folgt erledigen:

PHP-Code
$fileWriter = $logger->getLogWriter('file'); $logger->setLogDir('/path/to/log/dir');
Um Fehler beim Zugriff auf das Log-Verzeichnis zu vermeiden, sollte der Pfad absolut definiert sein!
4.1.2. Log-Verzeichnis-Berechtigung

Wurde das im Konstruktor oder der Methode setLogDir() angegebene Verzeichnis noch nicht erstellt, so legt der FileLogWriter dieses automatisch an. Um die verwendete Datei-Maske definieren zu können, stellt der FileLogWriter die Methode setLogFolderPermissions() bereit. Nutzen Sie diese wie folgt um die umask festzulegen:

PHP-Code
$fileWriter = $logger->getLogWriter('file'); $fileWriter->setLogFolderPermissions(0755);
4.1.3. Host-Präfix

In geclusterten Umgebungen werden Log-Dateien von verschiedenen Servern oft auf ein gemeinsames Datei-System geschrieben. Vorteil dieser Vorgehensweise ist, dass Log-Dateien zentral ausgewertet und archiviert werden können. Der Nachteil besteht darin, dass die Server des Clusters beim Schreiben der Dateien um Zugriff konkurrieren und sich so die Performance der Anwendung durch langes Warten oder erhöhten Log-Traffic (erfahrungsgemäß) verringert.

Eine oft eingesetzte Lösung ist, in geclusterten Umgebungen die einzelnen Log-Dateien mit einem Präfix zu verstehen, das den Server-Namen enthält. So sind die Dateinamen nicht nur eindeutig, sondern lassen auch die Analyse einer Anwendung auf einem dedizierten Server zu.

Mit dem in Release 1.15 eingeführten host prefix haben Sie die Möglichkeit, einen Server-abhängigen Präfix für eine Log-Datei zu definieren:

PHP-Code
$fileWriter = $logger->getLogWriter('file'); $fileWriter->setHostPrefix('node1');
Um die Konfiguration des Präfix möglichst einfach zu gestalten empfiehlt es sich, Umgebungs- oder Server-Konfigurationen auszulesen. Der folgende Code zeigt dies an Hand der $_SERVER-Superglobal-Variable:
PHP-Code
$fileWriter = $logger->getLogWriter('file'); $fileWriter->setHostPrefix($_SERVER['SERVER_ADDR']);

4.2. StdOutWriter

Der StdOutLogWriter schreibt die hinzugefügten Log-Einträge auf die Standard-Ausgabe des Webservers. Dadurch sind die Log-Einträge für den Besucher sichtbar.

Log-Einträge können prinzipiell sensible Daten der Applikation enthalten. Aus Sicherheitsgründen sollte der StdOutWriter daher nur in Entwicklungsumgebungen zum Einsatz kommen!

Die Registrierung des StdOutLogWriter kann in der Bootstrap-Datei wie folgt erfolgen:

PHP-Code
use APF\core\logging\writer\StdOutLogWriter; $logger->addLogWriter('stdout', new StdOutLogWriter());

Log-Einträge mit dem Ziel stdout werden nun zusammen mit dem Quelltext der Applikation ausgegeben.

4.3. DatabaseLogWriter

Der DatabaseLogWriter ermöglicht die Ausgabe der Log-Einträge in eine Datenbank-Tabelle. Erstellen Sie hierzu zunächst eine Tabelle mit dem folgenden SQL-Statement:

SQL-Statement
CREATE TABLE IF NOT EXISTS `{$this->logTable}` ( `target` varchar(10) NOT NULL default '', `timestamp` timestamp NOT NULL default CURRENT_TIMESTAMP, `severity` varchar(10) NOT NULL default '', `message` text NOT NULL );

Der Wert {$this->logTable} entspricht dabei dem Namen der Tabelle, mit dem der DatabaseLogWriter registriert werden soll. Auf diese Weise ist es möglich, verschiedene Instanzen des DatabaseLogWriter für unterschiedliche Log-Tabellen zu registrieren.

Um den LogWriter zu verwenden, nutzen Sie bitte folgenden Code-Block:

PHP-Code
use APF\core\logging\writer\DatabaseLogWriter; $logger->addlogWriter('db', new DatabaseLogWriter('my-connection', 'app_logs'));

Das erste Argument des Konstruktors referenziert die Datenbank-Verbindung, die mit Hilfe des ConnectionManager erzeugt wird, der zweite Parameter benennt die Log-Tabelle.

Der DatabaseLogWriter nutzt das Log-Ziel unter dem er registriert wurde als Merkmal in der Log-Tabelle. Dies ermöglicht daher die Wiederverwendung einer einzigen Implementierung für mehrere Anwendungsfälle (falls erwünscht).

4.4. GraphiteLogWriter

Der GraphiteLogWriter - zusammen mit dem GraphiteLogEntry - ist eine Implementierung für das System-Monitoring-Tool Graphite. Mit Hilfe des GraphiteLogEntry können Sie auf einfache Weise Monitoring Metriken an einen statsd-Daemon schicken.

Zur Registrierung des GraphiteLogWriter können Sie folgenden Code nutzen:

PHP-Code
use APF\core\logging\writer\GraphiteLogWriter; $logger->addlogWriter('graphite', new GraphiteLogWriter('my-graphite-host', '1234'));

Da die Implementierung des GraphiteLogEntry bereits alle notwendigen Formatierungen vornimmt, kann beim GraphiteLogWriter lediglich das Trennzeichen zwischen mehreren Einträgen konfiguriert werden. Nutzen Sie hierzu bitte die Methode setEntrySeparator() und übergeben dieser das gewünschte Trennzeichen (Standard: \n).

Die Verwendung des GraphiteLogWriter gestaltet sich wie folgt:

PHP-Code
use APF\core\singleton\Singleton; use APF\core\benchmark\BenchmarkTimer; $t = Singleton::getInstance('APF\core\benchmark\BenchmarkTimer'); $renderingTime = round(floatval($t->getTotalTime() * 1000)); use APF\core\logging\entry\GraphiteLogEntry; $logger->addEntry(new GraphiteLogEntry( 'graphite', 'rendering-time', 'ms', $renderingTime, LogEntry::SEVERITY_INFO ));
Bei der Nutzung der Python-Implementierung von statds kann es zu Problemem beim gleichzeitigen Versenden von mehreren Metriken kommen. Um dies zu lösen, können Sie den Bulk-Versand des GraphiteLogWriter deaktivieren. Nutzen Sie hierzu entweder das dritte Konstruktor-Argument bei der Erzeugung des LogWriter oder übergeben Sie die Methode setBatchWrites() den Wert false:
PHP-Code
// Konfiguration über den Konstruktor use APF\core\logging\writer\GraphiteLogWriter; $logger->addlogWriter( 'graphite', new GraphiteLogWriter('my-graphite-host', '1234', false) ); // Nachträgliche Konfiguration $writer = $logger->getLogWriter('graphite'); $writer->setBatchWrites(false);

5. Verwendung

Zur Verwendung des Loggers muss zunächst via

PHP-Code
use APF\core\singleton\Singleton; use APF\core\logging\Logger; $logger = &Singleton::getInstance('APF\core\logging\Logger');

eine Referenz auf die Instanz des Loggers im aktuellen Gültigkeitsbereich erzeugt werden. Das Hinzufügen eines Eintrags mit dem Inhalt MESSAGE zu einem Logfile mit dem Namen FILENAME ist mit dem Aufruf

PHP-Code
$log->logEntry('FILENAME', 'MESSAGE');

erledigt. Der dritte Parameter (optional) der Methode logEntry() definiert die SEVERITY der Meldung. Die verfügbaren Werte für den Schweregrad sind im Interface LogEntry definiert.

Ab Version 1.17 kann ebenso die Methode addEntry() genutzt werden. Diese erwartet eine Instanz des Interfaces LogEntry:

PHP-Code
use APF\core\logging\SimpleLogEntry; $log->addEntry(new SimpleLogEntry('FILENAME', 'MESSAGE'));
Sollte die Applikation exzessives Logging betreiben, kann es sinnvoll sein zu Gunsten einer geringeren Speicher-Auslastung den Log-Buffer innerhalb eines Requests mehrmals zu leeren. Hierzu besitzt der Logger ab Version 1.14 eine Buffer-Größe, die mit der Methode setMaxBufferLength() auch nachträglich definiert werden kann. Überschreitet der Puffer die standardmäßig oder durch Aufruf der genannten Methode definierten Grenzwert, wird der Inhalt in die entsprechende Log-Datei geschrieben und anschließend geleert.

6. LogWriter-Implementierung

Das in Kapitel 2 beschriebene Interface umfasst die Methoden writeLogEntries() und setTarget(). Die erste Methode kümmert sich bei der Implementierung eines LogWriter um die Persistenz der übergebenen Einträge, die zweite nimmt den Ziel-Bezeichner entgegen.

Während der Registrierung eines LogWriters mit Hilfe der Methode Logger::addLogWriter() injiziert der Logger den Ziel-Bezeichner über die Methode LogWriter::setTarget() unter dem der LogWriter registriert wurde.

Das Interface LogWriter definiert selbst keinen Konstruktor um die Implementierung hinsichtlich ihrer Konfigurierbarkeit nicht einzuschränken.

Bitte achten Sie darauf, dass der Konstruktor alle notwendigen Informationen zur Ausführung einer eigenen LogWriter-Implementierung enthält. So stellen Sie sicher, dass bei der Ausführung potentiell keine Fehler auftreten.

Als Implementierungsbeispiel soll im Folgenden ein LogWriter erstellt werden, der die übergebenen Einträge an den Syslog-Daemon übergibt. Hierzu kann die PHP-Funktion syslog(int $priority, string $message) genutzt werden. Die Implementierung gestaltet sich wie folgt:

PHP-Code
use APF\core\logging\LogWriter; class SysLogWriter implements LogWriter { private $target; public function writeLogEntries(array $entries) { define_syslog_variables(); openlog($this->target, LOG_PID, LOG_LOCAL0); foreach ($entries as $entry) { syslog( $this->getMappedSeverity($entry->getSeverity()), $entry ); } closelog(); } public function setTarget($target) { $this->target = $target; } private function getMappedSeverity($severity) { if ($severity == LogEntry::SEVERITY_DEBUG) { return LOG_DEBUG; } if ($severity == LogEntry::SEVERITY_ERROR) { return LOG_ERR; } if ($severity == LogEntry::SEVERITY_FATAL) { return LOG_EMERG; } if ($severity == LogEntry::SEVERITY_TRACE) { return LOG_NOTICE; } if ($severity == LogEntry::SEVERITY_WARNING) { return LOG_WARNING; } return LOG_INFO; } }

Um die Implementierung einzusetzen, kann diese wie folgt beim Logger registriert werden:

PHP-Code
$logger->addLogWriter('syslog', new SysLogWriter());

7. LogEntry-Implementierung

Das in Kapitel 2 beschriebe Interface umfasst die Methoden getLogTarget(), getSeverity() und __toString(). Die ersten beiden Methode geben Log-Ziel und severity-Definition aus, die letzte erzeugt das Format bzw. den Inhalt des Log-Eintrags.

Beim Hinzufügen eines Log-Eintrags mit den Methoden logEntry() (nutzt intern die LogEntry-Implementierung SimpleLogEntry) bzw. addEntry() (beliebige Implementierungen nutzbar) sortiert der Logger die übergebenen Einträge bereits an Hand des Log-Ziels (Rückgabe der Methode getLogTarget()) für die Verarbeitung an Ende des Requests vor.

Das Interface LogEntry definiert selbst keinen Konstruktor um die Implementierung hinsichtlich der Inhalte nicht einzuschränken.

Bitte achten Sie darauf, dass der Konstruktor alle relevanten Informationen enthält, der bei der Generierung des Formats benötigt wird.

Als Implementierungsbeispiel soll im Folgenden ein CsvLogEntry erstellt werden, der die übergebenen Inhalte im comma separated values Stil speichert. Die Implementierung gestaltet sich wie folgt:

PHP-Code
use APF\core\logger\LogEntry; class CsvLogEntry implements LogEntry { private $target; private $severity; private $message; private $date; private $time; public function __construct($target, $message, $severity) { $this->date = date('Y-m-d'); $this->time = date('H:i:s'); $this->target = $target; $this->message = $message; $this->severity = $severity; } public function __toString() { return $this->date . ';' . $this->time . ';' . $this->severity . ';' . $this->message; } public function getLogTarget() { return $this->target; } public function getSeverity() { return $this->severity; } }

Möchten Sie statt einem SimpleLogEntry die CsvLogEntry-Implementierung nutzen, so bietet Ihnen die Methode Logger::addEntry() das passende Interface dazu:

PHP-Code
use VENDOR\logging\entries\CsvLogEntry; $logger->addEntry(new CsvLogEntry( 'csv-file', 'There is something wrong!', LogEntry::SEVERITY_ERROR ));

Um eine CSV-Datei mit der vorliegenden Implementierung zu erstellen, muss für das Log-Ziel csv-file zunächst per

PHP-Code
use APF\core\logging\writer\FileLogWriter; $logger->addLogWriter('csv-file', new FileLogWriter('../logs'));

ein entsprechender LogWriter registriert werden.

Kommentare

Möchten Sie den Artikel eine Anmerkung hinzufügen, oder haben Sie ergänzende Hinweise? Dann können Sie diese hier einfügen. Die bereits verfassten Anmerkungen und Kommentare finden Sie in der untenstehenden Liste.
Für diesen Artikel liegen aktuell keine Kommentare vor.