PHP-FPM Performance-Debugging: Slow Logs mit Lescopr und XHProf in Symfony und Laravel korrelieren

PHP-FPM Performance-Debugging: Slow Logs mit Lescopr und XHProf in Symfony und Laravel korrelieren

Langsame Requests in PHP-FPM sind ein häufiges Problem für Backend-Entwickler, insbesondere in Symfony- oder Laravel-Anwendungen. Während Slow Logs von PHP-FPM die betroffenen Requests identifizieren, liefert XHProf detaillierte Einblicke in die Ausführungszeit einzelner Funktionen. Doch erst die Kombination mit einem APM-Tool wie Lescopr ermöglicht es, diese Daten in einen größeren Kontext zu setzen – etwa die Korrelation mit Datenbankabfragen, externen API-Aufrufen oder Memory-Leaks. Dieser Leitfaden zeigt Ihnen Schritt für Schritt, wie Sie diese Tools effektiv einsetzen, um Performance-Engpässe präzise zu lokalisieren und zu beheben.

Warum Slow Logs allein nicht ausreichen

Die Slow Logs von PHP-FPM sind ein erster Ansatzpunkt, um langsame Requests zu identifizieren. Sie zeichnen Requests auf, deren Ausführungszeit einen definierten Schwellenwert überschreitet, und liefern grundlegende Informationen wie:

• Die Request-URL und die ausführende PHP-Datei
• Die Gesamtausführungszeit und den Speicherverbrauch
• Die Start- und Endzeit des Requests

Allerdings fehlen in den Slow Logs entscheidende Details:

• Welche Code-Pfade sind für die Verzögerung verantwortlich?
• Welche Datenbankabfragen oder externe Services blockieren den Request?
• Wie hoch ist der Overhead durch Frameworks wie Symfony oder Laravel?

Ohne diese Informationen bleibt die Ursachenanalyse ein Ratespiel. Hier kommt XHProf ins Spiel.

XHProf: Low-Level-Profiling für präzise Analysen

XHProf ist ein hierarchisches Profiler-Tool für PHP, das detaillierte Einblicke in die Ausführungszeit und den Speicherverbrauch einzelner Funktionen liefert. Im Gegensatz zu anderen Profilern wie Xdebug ist XHProf speziell für die Analyse von Produktionsumgebungen optimiert und hat einen geringeren Overhead.

Installation und Konfiguration

1. XHProf installieren XHProf ist in den meisten PHP-Distributionen als PECL-Erweiterung verfügbar. Installieren Sie es mit:

   pecl install xhprof
   

   Aktivieren Sie die Erweiterung in Ihrer php.ini:

   extension=xhprof.so
   

2. XHProf in PHP-FPM aktivieren Fügen Sie in Ihrer php-fpm.conf oder pool.conf folgende Zeilen hinzu, um das Profiling für langsame Requests zu aktivieren:

   xhprof.output_dir = /tmp/xhprof
   xhprof.flags = XHPROF_FLAGS_CPU + XHPROF_FLAGS_MEMORY
   

3. Slow Logs und XHProf kombinieren Nutzen Sie ein Skript, das automatisch XHProf-Daten für Requests generiert, die in den Slow Logs auftauchen. Ein einfaches Beispiel:

   <?php
   if (isset($_SERVER['PHP_FPM_SLOW_LOG'])) {
       xhprof_enable(XHPROF_FLAGS_CPU + XHPROF_FLAGS_MEMORY);
       register_shutdown_function(function() {
           $data = xhprof_disable();
           file_put_contents(
               '/tmp/xhprof/' . uniqid() . '.xhprof',
               serialize($data)
           );
       });
   }
   

Analyse der XHProf-Daten

Die von XHProf generierten Daten können mit Tools wie XHGUI oder QCacheGrind visualisiert werden. Achten Sie auf folgende Metriken:

• Wall Time: Die tatsächliche Ausführungszeit einer Funktion, inklusive Wartezeiten.
• CPU Time: Die reine Rechenzeit, ohne Wartezeiten.
• Memory Usage: Der Speicherverbrauch pro Funktion.
• Calls: Die Anzahl der Aufrufe einer Funktion.

Typische Performance-Probleme, die sich mit XHProf identifizieren lassen:

• N+1-Probleme in ORMs wie Doctrine oder Eloquent
• Ineffiziente Datenbankabfragen mit hohen Latenzzeiten
• Blockierende externe API-Aufrufe (z. B. Zahlungsanbieter, Microservices)
• Overhead durch Framework-Features (z. B. Event-Listener, Middleware)

Lescopr: APM-Kontext für eine ganzheitliche Analyse

Während XHProf detaillierte Einblicke in den Code liefert, fehlt oft der Kontext zu anderen Komponenten Ihrer Anwendung. Hier setzt Lescopr an: Als APM- und Observability-Plattform korreliert es die Daten aus Slow Logs und XHProf mit:

• Datenbankabfragen (MySQL, PostgreSQL, Redis)
• Externe API-Aufrufe (HTTP-Requests, gRPC)
• Error-Tracking (PHP-Exceptions, Logs)
• Infrastruktur-Metriken (CPU, Memory, Network)

Integration von Lescopr in Symfony und Laravel

1. Lescopr-Agent installieren Der Lescopr-Agent wird als PHP-Erweiterung oder über Composer installiert. Für Symfony:

   composer require lescopr/lescopr-symfony
   

   Für Laravel:

   composer require lescopr/lescopr-laravel
   

2. Konfiguration Fügen Sie Ihre API-Schlüssel und die Umgebungsinformationen (z. B. production, staging) in der Konfigurationsdatei hinzu. Beispiel für Symfony:

   # config/packages/lescopr.yaml
   lescopr:
       api_key: 'IHR_API_SCHLÜSSEL'
       environment: 'production'
       slow_logs:
           enabled: true
           threshold: 5.0  # Sekundenschwelle für Slow Logs
   

3. Korrelation der Daten Lescopr sammelt automatisch:

   • Slow Logs aus PHP-FPM
   • XHProf-Daten (falls aktiviert)
   • Datenbank- und API-Metriken
   • Error-Logs und Traces

   Diese Daten werden in einem zentralen Dashboard zusammengefasst, das Ihnen ermöglicht:

   • Langsame Requests nach Ursache zu filtern (z. B. Datenbank, externer Service, Code)
   • Trends über die Zeit zu analysieren (z. B. steigende Latenz in einer bestimmten Route)
   • SLA-Dashboards zu erstellen, um die Einhaltung von Performance-Zielen zu überwachen

Praktisches Beispiel: Debugging eines langsamen Requests

Angenommen, Sie haben einen langsamen Request in Ihrer Symfony-Anwendung identifiziert, der in den Slow Logs mit einer Ausführungszeit von 8 Sekunden auftaucht. Mit Lescopr gehen Sie wie folgt vor:

1. Request im Dashboard identifizieren Filtern Sie im Lescopr-Dashboard nach Requests mit einer Latenz > 5 Sekunden. Sie sehen den betroffenen Endpunkt (z. B. /api/orders) und die zugehörige Trace-ID.

2. XHProf-Daten analysieren Klicken Sie auf die Trace-ID, um die XHProf-Daten für diesen Request anzuzeigen. Sie erkennen, dass die Funktion OrderRepository::findByUser() 6 Sekunden der Gesamtzeit verbraucht.

3. Datenbankabfragen prüfen Lescopr zeigt Ihnen die SQL-Abfragen, die während des Requests ausgeführt wurden. Sie stellen fest, dass eine Abfrage auf die Tabelle orders 5.8 Sekunden dauert – ein klassisches N+1-Problem.

4. Lösung implementieren Sie optimieren die Abfrage durch Eager Loading in Doctrine:

   // Vorher (N+1-Problem)
   $orders = $orderRepository->findBy(['user' => $user]);
   
   // Nachher (Eager Loading)
   $orders = $orderRepository->findBy(['user' => $user], ['join' => ['user' => 'orders']]);
   

5. Ergebnis überprüfen Nach dem Deployment sehen Sie im Lescopr-Dashboard, dass die Latenz des Requests auf 1,2 Sekunden gesunken ist. Die Korrelation der Daten hat Ihnen geholfen, das Problem präzise und schnell zu lösen.

Best Practices für das Performance-Debugging

1. Selektives Profiling

XHProf hat einen Overhead von etwa 5-10% pro Request. Aktivieren Sie das Profiling daher nur für verdächtige Requests, um die Performance Ihrer Anwendung nicht unnötig zu beeinträchtigen. Nutzen Sie:

• Slow Logs als Trigger: Aktivieren Sie XHProf nur für Requests, die in den Slow Logs auftauchen.
• Sampling: Profilen Sie nur einen bestimmten Prozentsatz der Requests (z. B. 10%).

2. Automatisierte Alerts

Richten Sie in Lescopr Alerts ein, die Sie benachrichtigen, wenn:

• Die durchschnittliche Latenz einer Route einen Schwellenwert überschreitet.
• Die Error-Rate in einem bestimmten Zeitfenster steigt.
• Datenbankabfragen länger als eine definierte Zeit dauern.

3. Langfristige Analyse

Nutzen Sie Lescopr, um Trends über die Zeit zu analysieren. Fragen Sie sich:

• Welche Routes haben die höchste Latenz?
• Welche Datenbankabfragen sind am langsamsten?
• Welche externen Services verursachen die meisten Blockaden?

Diese Daten helfen Ihnen, proaktiv Performance-Probleme zu identifizieren, bevor sie zu Ausfällen führen.

Häufige Fallstricke und Lösungen

Fazit: Effizientes Performance-Debugging mit der richtigen Tool-Kombination

Langsame PHP-FPM-Requests in Symfony oder Laravel zu debuggen, erfordert mehr als nur Slow Logs oder XHProf allein. Erst die Korrelation dieser Daten mit einem APM-Tool wie Lescopr ermöglicht es Ihnen, Performance-Engpässe präzise zu identifizieren und zu beheben. Durch die Kombination aus Low-Level-Profiling (XHProf), Slow Logs (PHP-FPM) und APM-Kontext (Lescopr) erhalten Sie ein ganzheitliches Bild Ihrer Anwendung – von der Code-Ebene bis zur Infrastruktur.

Für mehr Details: Die Lescopr-Dokumentation beschreibt die Einrichtung Schritt für Schritt.