{"id":20986,"date":"2026-08-25T11:50:02","date_gmt":"2026-08-25T09:50:02","guid":{"rendered":"https:\/\/webhosting.de\/php-fpm-slowlog-richtig-auswerten-performance-optimierung-debugging-analyse\/"},"modified":"2026-08-25T11:50:02","modified_gmt":"2026-08-25T09:50:02","slug":"php-fpm-slowlog-analisi-corretta-ottimizzazione-delle-prestazioni-debug-analisi","status":"publish","type":"post","link":"https:\/\/webhosting.de\/it\/php-fpm-slowlog-richtig-auswerten-performance-optimierung-debugging-analyse\/","title":{"rendered":"Analizzare correttamente lo slowlog di PHP-FPM: individuare con certezza i colli di bottiglia delle prestazioni"},"content":{"rendered":"<p>Ti mostro come fare il <strong>Slowlog di PHP-FPM<\/strong> analizzi in modo mirato, interpreti correttamente i backtrace e ne ricavi indicazioni chiare per ridurre la latenza. In questo modo individuerai in modo affidabile i colli di bottiglia delle prestazioni, stabilirai le priorit\u00e0 degli interventi e renderai i tempi di caricamento sensibilmente pi\u00f9 veloci per gli utenti.<\/p>\n\n<h2>Punti centrali<\/h2>\n\n<ul>\n  <li><strong>Backtrace<\/strong> Leggere: il frame #0 mostra la pastiglia del freno attualmente in uso.<\/li>\n  <li><strong>Timeout<\/strong> Scegliere: iniziare da un livello alto, poi abbassare gradualmente.<\/li>\n  <li><strong>Correlazione<\/strong> Con il log di accesso: identificare con certezza gli URL lenti.<\/li>\n  <li><strong>Campione<\/strong> contare: dare priorit\u00e0 alle funzioni ricorrenti.<\/li>\n  <li><strong>Correzioni al codice<\/strong> dedurre: affrontare in modo mirato DB, API, loop e plugin.<\/li>\n<\/ul>\n\n<h2>Che cos\u2019\u00e8 lo slowlog di PHP-FPM?<\/h2>\n\n<p>Lo Slowlog registra, per le richieste lunghe, un <strong>Backtrace<\/strong> in un file di log, registrando cos\u00ec il punto di esecuzione corrente senza interrompere la richiesta. In questo modo riconosco immediatamente quale script, quale URL e quale funzione sta bloccando il flusso. Le voci contengono il timestamp, il pool, il nome del file dello script, l\u2019URI della richiesta e la catena delle chiamate alle funzioni. In questo modo lo slowlog si distingue chiaramente dai classici log di errore, poich\u00e9 documenta le prestazioni, non gli errori. Per siti molto trafficati come i backend di WordPress, fornisce indicazioni rapidamente utilizzabili su query costose, rendering eccessivo o operazioni di I\/O che causano blocchi. Chi comprende queste istantanee pu\u00f2 molto rapidamente <strong>causa principale<\/strong> delimitare il problema e pianificare le misure da adottare.<\/p>\n\n<h2>Ecco come funziona lo Slowlog nella vita di tutti i giorni<\/h2>\n\n<p>Una volta attivato, PHP-FPM genera un <strong>Istantanea<\/strong> dello stack nel log, mentre la richiesta prosegue. Ogni voce inizia in genere con \u201e#0\u201c, ovvero nel punto in cui si sta verificando una perdita di tempo. Tra i blocchi noto spesso righe vuote, il che semplifica la separazione degli eventi. Il metodo fornisce campioni anzich\u00e9 profili completi, ma in compenso offre indicazioni precise sui veri e propri colli di bottiglia, come percorsi di template complessi, hook orfani o chiamate di rete lente. Nelle fasi di traffico intenso, collego questi indizi ai picchi di carico e in questo modo classifichio in modo chiaro le sezioni di codice. Non appena individuo modelli ricorrenti, ad esempio, <strong>pm.max_children<\/strong> e utilizza a tal fine le informazioni contenute in <a href=\"https:\/\/webhosting.de\/it\/php-fpm-gestione-dei-processi-pm-max-children-ottimizzare-core\/\">Impostare correttamente il valore di pm.max_children<\/a>.<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img fetchpriority=\"high\" decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/08\/php-slowlog-analyse-6392.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Attivare e configurare Slowlog<\/h2>\n\n<p>Attivo la funzione nel pool corrispondente e definisco il percorso, il timeout e la profondit\u00e0 della traccia, in modo che la <strong>Valutazione<\/strong> rimanga gestibile. Successivamente riavvio PHP-FPM e verifico se il file di log \u00e8 scrivibile con i permessi dell\u2019utente del pool. Come valore iniziale imposto spesso 5 secondi, per individuare innanzitutto gli eventi anomali pi\u00f9 evidenti senza sovraccaricare il sistema con i dati di log. Successivamente, non appena i problemi pi\u00f9 grossolani sono stati risolti, riduco gradualmente il valore. Per garantire log gestibili, limito la profondit\u00e0 di tracciamento a 20-30 frame, il che nella pratica \u00e8 solitamente sufficiente. In questo modo mantengo la <strong>Dimensione del file<\/strong> sotto controllo e non tralasciare alcun dettaglio rilevante.<\/p>\n\n<table>\n  <thead>\n    <tr>\n      <th>Impostazione<\/th>\n      <th>Scopo<\/th>\n      <th>valore iniziale<\/th>\n      <th>Note<\/th>\n    <\/tr>\n  <\/thead>\n  <tbody>\n    <tr>\n      <td><code>slowlog<\/code><\/td>\n      <td>Percorso del file di log<\/td>\n      <td>\/var\/log\/php-fpm\/www-slow.log<\/td>\n      <td>Verificare i percorsi a seconda della distribuzione; diritti di scrittura per <strong>www-data<\/strong> garantire<\/td>\n    <\/tr>\n    <tr>\n      <td><code>timeout_richiesta_slowlog<\/code><\/td>\n      <td>Soglia per \u201elento\u201c<\/td>\n      <td>5 s<\/td>\n      <td>Iniziare in grande, poi... <strong>abbassare<\/strong> (ad es. 2\u20133 s)<\/td>\n    <\/tr>\n    <tr>\n      <td><code>request_slowlog_trace_depth<\/code><\/td>\n      <td>Profondit\u00e0 massima del backtrace<\/td>\n      <td>20\u201330<\/td>\n      <td>Mantieni le tracce leggibili, senza <strong>Informazioni essenziali<\/strong> perdere<\/td>\n    <\/tr>\n  <\/tbody>\n<\/table>\n\n<h2>Trovare il file di log e consultarlo rapidamente<\/h2>\n\n<p>Per prima cosa controllo i percorsi configurati e apro il log con <strong>meno<\/strong> oppure controlla le ultime righe con <code>tail -40<\/code>. In questo modo vedo subito se arrivano nuove voci e quali script ricorrono pi\u00f9 spesso. Per orientarmi rapidamente, faccio attenzione ai nomi dei file, ai pool interessati e agli URI che saltano all\u2019occhio. Se non trovo voci, attivo le opzioni nel pool, ricarico il servizio e controllo il proprietario e i diritti. Negli ambienti gestiti, inoltre, consulto il pannello o gli script di avvio per assicurarmi che lo slowlog sia effettivamente <strong>segue<\/strong>.<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/08\/phpfpm_slowlogs4357.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Riconoscere i blocchi e contare gli schemi<\/h2>\n\n<p>Ogni voce appare come un blocco, spesso separato da una <strong>Riga vuota<\/strong>, il che facilita il conteggio. Mi baso sulle righe \u201e#0\u201c, poich\u00e9 indicano il punto di esecuzione corrente in cui si verifica una perdita di tempo. Tramite semplici pipeline della shell filtro le funzioni principali e individuo i punti che causano pi\u00f9 spesso rallentamenti. In questo modo do la priorit\u00e0 in modo mirato alle funzioni che, nel complesso, richiedono pi\u00f9 tempo. Successivamente verifico se questi punti critici si verificano solo nei picchi di carico o se causano problemi in modo costante. Questa classificazione determina la <strong>Sequenza<\/strong> le mie misure.<\/p>\n\n<h2>Leggi le voci: dal frame #0 fino all'inizio<\/h2>\n\n<p>Quando leggo i post, inizio dall'inizio, ovvero da <strong>#0<\/strong> e procedo passo dopo passo verso il basso per comprendere il percorso dal punto di ingresso alla posizione attuale. Lunghe catene di template indicano un rendering dispendioso, molti hook segnalano un eccesso di plugin e un\u2019elevata presenza di SQL denota la mancanza di indici. Mi annoto i numeri di riga, i nomi delle funzioni e i percorsi dei file, in modo da poter ritrovare rapidamente il codice. Se lo stack sembra presentare loop o operazioni ripetitive, controllo la memoria temporanea e il caching. In questo modo non perdo tempo nella <strong>Localizzazione<\/strong> del problema nel codice.<\/p>\n\n<h2>Correlare Slowlog con i log di accesso<\/h2>\n\n<p>Collegher\u00f2 lo Slowlog ai log del server web, in modo da poter identificare le richieste lente relative a una specifica <strong>URL<\/strong> posso associare. Tramite i timestamp e, facoltativamente, i PID, trovo le voci corrispondenti nei log di Nginx o Apache. In questo modo riesco a individuare parametri, user-agent e tempi di risposta al di fuori di PHP. Se si riscontrano visitatori ricorrenti o stringhe di query identiche, avvio una simulazione proprio con questi scenari. In questo modo individuo rapidamente casi riproducibili e mantengo la <strong>Tempo di analisi<\/strong> in breve.<\/p>\n\n<h2>Ridurre il valore di soglia in modo iterativo<\/h2>\n\n<p>Comincio con una soglia generosa, risolvendo prima i problemi pi\u00f9 gravi <strong>I valori fuori norma<\/strong> e poi lo riduco gradualmente. Questo processo riduce il volume dei log e concentra la mia energia sulle correzioni pi\u00f9 proficue. Dopo ogni ciclo di ottimizzazione, scelgo una soglia pi\u00f9 bassa e raccolgo nuovamente i dati. In questo modo passo da una selezione approssimativa alla messa a punto fine, senza perdermi nel rumore di fondo. Il risultato sono adeguamenti mirati e una <strong>chiaro<\/strong> Panoramica dei colli di bottiglia rimanenti.<\/p>\n\n<h2>Dallo slowlog alla soluzione: soluzioni tipiche<\/h2>\n\n<p>Se il frame superiore mostra le funzioni del database, controllo le istruzioni SQL con <strong>SPIEGARE<\/strong>, inserisco gli indici mancanti e limito i set di risultati. Per i servizi remoti, riduco i timeout, gestisco le risposte in modo asincrono o memorizzo i risultati nella cache. Se individuo cicli dispendiosi, semplifico la logica, riduco il numero di iterazioni e utilizzo strutture pi\u00f9 efficienti. In WordPress contrassegno gli hook ricorrenti, sostituisco le estensioni pesanti e opto per un tema pi\u00f9 leggero. Se il numero di processi PHP blocca l\u2019elaborazione, tengo d\u2019occhio i tempi di attesa e, a integrazione di <strong>Backtraces<\/strong> anche le code, ad esempio tramite <a href=\"https:\/\/webhosting.de\/it\/php-accodamento-delle-richieste-limiti-massimi-di-elaborazione-dei-bambini-prestazioni\/\">Accodamento delle richieste PHP<\/a>.<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/08\/PHP-FPM-Slowlog-Analyse-4958.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Funzionamento continuo: gestione efficiente dei log<\/h2>\n\n<p>Non mantengo la registrazione sempre al massimo, in modo che il <strong>Carico I\/O<\/strong> rimanga gestibile. Lavoro invece per fasi: valuto attivamente, ottimizzo, poi torno a un livello moderato. Con Logrotate mantengo i file snelli e archivia i dati obsoleti in formato compresso. Al termine di un\u2019analisi, alzo la soglia o disattivo temporaneamente lo slowlogging. Inoltre, documento le osservazioni e le correzioni, in modo che le successive verifiche abbiano un quadro chiaro <strong>traccia<\/strong> trovare.<\/p>\n\n<h2>Diagnosi dell'hosting: distinguere tra server e applicazione<\/h2>\n\n<p>La presenza di molti frame Slowlog identici in condizioni di elevato carico della CPU indica che <strong>Codice di applicazione<\/strong>, mentre la mancanza di voci sul lato server indica piuttosto problemi legati all\u2019I\/O, alla rete o al server del database. In questi casi, confronto il TTFB, i tempi PHP e la latenza upstream per individuare il collo di bottiglia. Se noto code e tempi di attesa elevati prima dell\u2019esecuzione, verifico i limiti e il numero di processi. A tal fine, integro la mia diagnosi con informazioni sull\u2019elaborazione delle richieste e tengo conto di eventuali limiti che rallentano l\u2019elaborazione. Per una valutazione approfondita, oltre ai log, consulto anche le indicazioni relative a <a href=\"https:\/\/webhosting.de\/it\/php-fpm-gestione-dei-processi-pm-max-children-ottimizzare-core\/\">Impostare correttamente il valore di pm.max_children<\/a> oppure articoli relativi ai tempi di attesa, in modo da poter <strong>Capacit\u00e0<\/strong> in modo ragionevole.<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/08\/phpfpm_slowlog_analysis_4732.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Esempio pratico: backend di WordPress lento<\/h2>\n\n<p>Ho impostato <strong>timeout_richiesta_slowlog<\/strong> Inizialmente imposto il tempo a 5 secondi, riavvio PHP-FPM e raccolgo dati per 30-60 minuti in condizioni di carico reale. Successivamente conto le funzioni \u201e#0\u201c pi\u00f9 frequenti e cerco hook ricorrenti o chiamate WP_Query dispendiose. Se sono coinvolti servizi esterni, misuro i tempi di risposta e memorizzo i risultati nella cache in modo mirato. Se le visualizzazioni delle pagine sono rallentate dagli accessi di sessione, verifico il comportamento di blocco e, se possibile, sposto le operazioni relative alla sessione fuori dal percorso critico. Soprattutto in caso di accessi e azioni amministrative, tester\u00f2 le impostazioni e disattiver\u00f2 i messaggi di avviso. <a href=\"https:\/\/webhosting.de\/it\/php-blocco-sessione-wordpress-login-lento-ottimizzazione-serverfix\/\">Blocco della sessione PHP<\/a> perch\u00e9 il mio <strong>Backend<\/strong> reagisce pi\u00f9 rapidamente.<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/08\/server-analyse-php-4782.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Progettazione del pool e diritti: una base solida per slowlogs utilizzabili<\/h2>\n<p>Separo le applicazioni in file separati <strong>Piscine<\/strong> con nomi chiari (ad es. www, admin, api), imposta <code>ascoltare<\/code>-Prese e personalizzate <code>slowlog<\/code>-percorsi. In questo modo riesco a correlare pi\u00f9 facilmente le voci ed evito che si confondano. \u00c8 importante che siano coerenti <strong>Diritti dei file<\/strong>: L'utente del pool (spesso www-data) deve disporre dei diritti di scrittura sul percorso dei log e nella directory. Nelle configurazioni con container o chroot, verifico che i percorsi esistano nel namespace e siano persistenti; in caso contrario, i log andrebbero persi al riavvio.<\/p>\n\n<h2>Leggere in dettaglio un blocco di Slowlog e analizzarlo automaticamente<\/h2>\n<p>In genere, le voci iniziano con il timestamp, il pool, il nome del file di script e l\u2019URI della richiesta, seguiti dai frame. Conto le righe \u201e#0\u201c e le raggruppo in base al nome delle funzioni per evidenziare i punti critici. Con semplici pipe estraggo i punti di rallentamento:<\/p>\n<pre><code>grep -E \"^#0|request.uri|script_filename\" \/var\/log\/php-fpm\/www-slow.log | sed 's\/  *\/ \/g'\n<\/code><\/pre>\n<p>Oppure elenco i top frame pi\u00f9 frequenti:<\/p>\n<pre><code>grep \"^#0\" \/var\/log\/php-fpm\/www-slow.log | awk -F\": \" '{print $2}' | awk '{print $1}' | sort | uniq -c | sort -nr | head\n<\/code><\/pre>\n<p>Se voglio includere l'URL e il file, preparo dei blocchi tramite <code>awk<\/code> e annotami le combinazioni migliori tra funzione, URI e script. In questo modo stabilisco le priorit\u00e0 delle correzioni che apportano i maggiori benefici.<\/p>\n\n<h2>Mappa dei timeout: come interagiscono Slowlog, PHP e il server web<\/h2>\n<p>Per una diagnosi accurata, prescrivo <strong>tutti<\/strong> Timeout: <code>timeout_richiesta_slowlog<\/code> attiva lo snapshot, <code>tempo_di_esecuzione_max<\/code> limita il tempo di esecuzione di PHP nello script, <code>timeout_richiesta_termine<\/code> pu\u00f2 terminare forzatamente il processo FPM. Intervenire a livello del server web <em>fastcgi<\/em>\u2013 ovvero. <em>proxy<\/em>-Timeout (ad es. <code>fastcgi_read_timeout<\/code>) e i timeout dei client. Se imposto lo slowlog <em>sopra<\/em> a causa dei timeout del server, perdo dei dati; se invece <em>tra cui<\/em>, ottengo utili istantanee prima che le richieste si interrompano. Mantengo quindi volutamente questo ordine: timeout del server web &gt; terminazione di PHP &gt; slowlog &gt; latenza di destinazione.<\/p>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/08\/php-fpm-slow-logs-analysis-7125.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>Includere lo stato FPM, la coda e la gestione dei processi<\/h2>\n<p>Lo Slowlog mostra che, <em>dove<\/em> si spreca tempo \u2013 lo stato FPM rivela che, <em>perch\u00e9<\/em> Richieste in sospeso. Attivo l'endpoint di stato, monitoro <strong>inattivo<\/strong>, <strong>attivo<\/strong> e <strong>coda di ascolto<\/strong> e li confronto con i timestamp dello slowlog. Se la coda cresce mentre molti worker rimangono bloccati nelle stesse funzioni, il collo di bottiglia \u00e8 il codice; se la coda cresce senza un aumento dello slowlog, significa che manca capacit\u00e0 o che un elemento a monte sta rallentando il sistema. Sulla base di ci\u00f2, adeguo <code>pm<\/code>-Impostazioni (dinamiche\/su richiesta), <code>pm.max_children<\/code> e, se necessario,. <code>pm.max_requests<\/code>, per individuare eventuali perdite di memoria o frammentazione.<\/p>\n\n<h2>Caratteristiche specifiche nei container e negli ambienti gestiti<\/h2>\n<p>In Docker\/Kubernetes, FPM spesso registra i log in <strong>stdout\/stderr<\/strong> oppure in percorsi raccolti dagli aggregatori di log. Scelgo consapevolmente un <em>a<\/em> Eliminare, in modo da non avere voci duplicate o mancanti. Con <code>error_log = \/proc\/self\/fd\/2<\/code> e un dedicato <code>slowlog<\/code>-Gli snapshot che puntano a un volume persistente rimangono disponibili. Nelle configurazioni gestite, verifico se il provider di hosting abbia attivato o limitato gli slowlog e adeguo gli intervalli in modo da non entrare in conflitto con le rotazioni.<\/p>\n\n<h2>Privacy e sicurezza: registri senza rischi<\/h2>\n<p>I backtrace possono contenere informazioni sensibili <strong>Parametri<\/strong>, percorsi di file o ID di sessione. Riduco al minimo i rischi salvando le stringhe di query nei log di accesso, disattivando i messaggi di debug nel codice e limitando il numero di utenti autorizzati alla lettura. Per lo scambio con terze parti, anonimizzo i percorsi e rimuovo i token. Negli ambienti di produzione definisco periodi di conservazione brevi e applico la rotazione e la compressione dei log a livello di sistema.<\/p>\n\n<h2>WordPress: individuare rapidamente gli schemi ricorrenti<\/h2>\n<ul>\n  <li><strong>WP_Query\/WP_Meta_Query<\/strong>: Mancano gli indici su <code>postmeta<\/code> oppure, se si effettua un filtro su campi non indicizzati, i tempi di esecuzione aumentano vertiginosamente. Riduco le meta-query, utilizzo le tassonomie o impiego indici mirati.<\/li>\n  <li><strong>Transienti e cache degli oggetti<\/strong>: Molti calcoli simili indicano la mancanza di una cache persistente. Attivo la cache degli oggetti, ottimizzo le chiavi della cache e i TTL.<\/li>\n  <li><strong>Hook\/Filtri<\/strong>: Le lunghe catene di stack indicano la presenza di plugin superflui. Analizzo gli hook pi\u00f9 onerosi e rimuovo o sostituisco le estensioni.<\/li>\n  <li><strong>Richieste HTTP<\/strong>: Le chiamate API interne (wp_remote_get) dovrebbero utilizzare timeout, keep-alive e caching; se possibile, le risposte non devono bloccare il thread della richiesta.<\/li>\n  <li><strong>Rendering dei modelli<\/strong>: Profondit\u00e0 <code>get_template_part<\/code>- Le cascate con accessi ai file traggono vantaggio dalla memorizzazione nella cache e da una minore frammentazione.<\/li>\n<\/ul>\n\n<h2>Evitare fraintendimenti: ci\u00f2 che lo Slowlog non mostra<\/h2>\n<p>Lo snapshot \u00e8 un <strong>Istantanea<\/strong>. Non descrive l'intero ciclo di vita della richiesta, ma lo stato al momento dell'attivazione. Trappole comuni:<\/p>\n<ul>\n  <li><strong>Distorsione di campionamento<\/strong>: I percorsi rari ma estremamente costosi possono andare persi se il timeout \u00e8 troppo basso o se la fase \u00e8 stata breve.<\/li>\n  <li><strong>Chiamate di sistema che causano blocchi<\/strong>: <code>fopen<\/code>, <code>stat<\/code> oppure le ricerche DNS appaiono come funzioni PHP, mentre il tempo di attesa effettivo si verifica nel kernel o nella rete.<\/li>\n  <li><strong>Caricamento automatico<\/strong>: Molti piccoli file di include senza Opcache causano perdite di efficienza che nello stack sembrano innocue. Uno sguardo all'Opcache Hitrate aiuta a valutare la situazione.<\/li>\n<\/ul>\n\n<h2>Tenere sotto controllo CLI, Cron e webhook<\/h2>\n<p>Non tutti i problemi di prestazioni passano attraverso FPM. I pi\u00f9 gravosi <strong>Cronjobs<\/strong> (ad es. wp-cron), i queue worker o i webhook bloccano la CPU, l\u2019I\/O o il database, peggiorando cos\u00ec indirettamente i tempi di risposta. Isolo tali carichi in processi separati, li pianifico al di fuori dei picchi di traffico e verifico che vengano eseguiti tramite HTTP attivato da FPM anzich\u00e9 tramite CLI \u2013 altrimenti ci\u00f2 distorce la visione dello slowlog.<\/p>\n\n<h2>Come implementare la rotazione dei log in modo pratico<\/h2>\n<p>Per evitare che gli slowlog diventino troppo voluminosi, li ruoto frequentemente e comprimo i dati storici. Una rotazione tipica conserva poche generazioni, segnala a FPM di riaprire il file ed evita lacune. Importante: dopo la rotazione, far riaprire FPM (HUP) affinch\u00e9 le nuove voci non vengano perse. Adatto le impostazioni specifiche in base al traffico, al timeout e alla profondit\u00e0 di tracciamento.<\/p>\n\n<h2>Lista di controllo per ottenere risultati rapidi<\/h2>\n<ul>\n  <li>Attivare Slowlog per ogni pool, verificare i percorsi e i diritti.<\/li>\n  <li>Avviare con 5s, raccogliere i dati, contare i fotogrammi migliori.<\/li>\n  <li>Correlare con i log di Access: timestamp, URI, User-Agent.<\/li>\n  <li>Verificare i timeout dei server upstream e dei server web.<\/li>\n  <li>Monitorare lo stato dell'FPM e la coda, <strong>pm<\/strong>-Regolare i limiti.<\/li>\n  <li>Risolvere prima i punti critici: indici SQL, cache, hook costosi, I\/O.<\/li>\n  <li>Ridurre gradualmente il timeout, quindi effettuare una nuova misurazione.<\/li>\n  <li>Eseguire la rotazione dei log, documentare le informazioni acquisite, tenere traccia delle modifiche.<\/li>\n<\/ul>\n\n\n<figure class=\"wp-block-image size-full is-resized\">\n  <img decoding=\"async\" src=\"https:\/\/webhosting.de\/wp-content\/uploads\/2026\/08\/phpfpm_slowlogs4357.png\" alt=\"\" width=\"1536\" height=\"1024\"\/>\n<\/figure>\n\n\n<h2>In breve: la tua strada verso prestazioni migliori<\/h2>\n\n<p>Attivo lo Slowlog, leggo il <strong>Cornici di alta qualit\u00e0<\/strong>, incrocio i dati con i log di accesso e risolvo innanzitutto i valori anomali pi\u00f9 significativi. Successivamente abbasso la soglia, verifico gli schemi ricorrenti e implemento correzioni mirate nel codice, nella configurazione e nella cache. Grazie alla rotazione dei log e a timeout moderati, mantengo basso il carico operativo. Per WordPress mi concentro su query onerose, plugin, hook e possibili blocchi di sessione. In questo modo individuo in modo affidabile i veri <strong>Colli di bottiglia<\/strong> e fornisca risposte notevolmente pi\u00f9 rapide.<\/p>","protected":false},"excerpt":{"rendered":"<p>Scopri come interpretare correttamente lo slowlog di PHP-FPM e analizzare in dettaglio le richieste lente. Con questa guida potrai ottimizzare in modo mirato le prestazioni della tua applicazione PHP: l'introduzione perfetta al debug efficiente in PHP.<\/p>","protected":false},"author":1,"featured_media":20979,"comment_status":"","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[780],"tags":[],"class_list":["post-20986","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-administration-anleitungen"],"acf":[],"_wp_attached_file":null,"_wp_attachment_metadata":null,"litespeed-optimize-size":null,"litespeed-optimize-set":null,"_elementor_source_image_hash":null,"_wp_attachment_image_alt":null,"stockpack_author_name":null,"stockpack_author_url":null,"stockpack_provider":null,"stockpack_image_url":null,"stockpack_license":null,"stockpack_license_url":null,"stockpack_modification":null,"color":null,"original_id":null,"original_url":null,"original_link":null,"unsplash_location":null,"unsplash_sponsor":null,"unsplash_exif":null,"unsplash_attachment_metadata":null,"_elementor_is_screenshot":null,"surfer_file_name":null,"surfer_file_original_url":null,"envato_tk_source_kit":null,"envato_tk_source_index":null,"envato_tk_manifest":null,"envato_tk_folder_name":null,"envato_tk_builder":null,"envato_elements_download_event":null,"_menu_item_type":null,"_menu_item_menu_item_parent":null,"_menu_item_object_id":null,"_menu_item_object":null,"_menu_item_target":null,"_menu_item_classes":null,"_menu_item_xfn":null,"_menu_item_url":null,"_trp_menu_languages":null,"rank_math_primary_category":null,"rank_math_title":null,"inline_featured_image":null,"_yoast_wpseo_primary_category":null,"rank_math_schema_blogposting":null,"rank_math_schema_videoobject":null,"_oembed_049c719bc4a9f89deaead66a7da9fddc":null,"_oembed_time_049c719bc4a9f89deaead66a7da9fddc":null,"_yoast_wpseo_focuskw":null,"_yoast_wpseo_linkdex":null,"_oembed_27e3473bf8bec795fbeb3a9d38489348":null,"_oembed_c3b0f6959478faf92a1f343d8f96b19e":null,"_trp_translated_slug_en_us":null,"_wp_desired_post_slug":null,"_yoast_wpseo_title":null,"tldname":null,"tldpreis":null,"tldrubrik":null,"tldpolicylink":null,"tldsize":null,"tldregistrierungsdauer":null,"tldtransfer":null,"tldwhoisprivacy":null,"tldregistrarchange":null,"tldregistrantchange":null,"tldwhoisupdate":null,"tldnameserverupdate":null,"tlddeletesofort":null,"tlddeleteexpire":null,"tldumlaute":null,"tldrestore":null,"tldsubcategory":null,"tldbildname":null,"tldbildurl":null,"tldclean":null,"tldcategory":null,"tldpolicy":null,"tldbesonderheiten":null,"tld_bedeutung":null,"_oembed_d167040d816d8f94c072940c8009f5f8":null,"_oembed_b0a0fa59ef14f8870da2c63f2027d064":null,"_oembed_4792fa4dfb2a8f09ab950a73b7f313ba":null,"_oembed_33ceb1fe54a8ab775d9410abf699878d":null,"_oembed_fd7014d14d919b45ec004937c0db9335":null,"_oembed_21a029d076783ec3e8042698c351bd7e":null,"_oembed_be5ea8a0c7b18e658f08cc571a909452":null,"_oembed_a9ca7a298b19f9b48ec5914e010294d2":null,"_oembed_f8db6b27d08a2bb1f920e7647808899a":null,"_oembed_168ebde5096e77d8a89326519af9e022":null,"_oembed_cdb76f1b345b42743edfe25481b6f98f":null,"_oembed_87b0613611ae54e86e8864265404b0a1":null,"_oembed_27aa0e5cf3f1bb4bc416a4641a5ac273":null,"_oembed_time_27aa0e5cf3f1bb4bc416a4641a5ac273":null,"_tldname":null,"_tldclean":null,"_tldpreis":null,"_tldcategory":null,"_tldsubcategory":null,"_tldpolicy":null,"_tldpolicylink":null,"_tldsize":null,"_tldregistrierungsdauer":null,"_tldtransfer":null,"_tldwhoisprivacy":null,"_tldregistrarchange":null,"_tldregistrantchange":null,"_tldwhoisupdate":null,"_tldnameserverupdate":null,"_tlddeletesofort":null,"_tlddeleteexpire":null,"_tldumlaute":null,"_tldrestore":null,"_tldbildname":null,"_tldbildurl":null,"_tld_bedeutung":null,"_tldbesonderheiten":null,"_oembed_ad96e4112edb9f8ffa35731d4098bc6b":null,"_oembed_8357e2b8a2575c74ed5978f262a10126":null,"_oembed_3d5fea5103dd0d22ec5d6a33eff7f863":null,"_eael_widget_elements":null,"_oembed_0d8a206f09633e3d62b95a15a4dd0487":null,"_oembed_time_0d8a206f09633e3d62b95a15a4dd0487":null,"_aioseo_description":null,"_eb_attr":null,"_eb_data_table":null,"_oembed_819a879e7da16dd629cfd15a97334c8a":null,"_oembed_time_819a879e7da16dd629cfd15a97334c8a":null,"_acf_changed":null,"_wpcode_auto_insert":null,"_edit_last":null,"_edit_lock":null,"_oembed_e7b913c6c84084ed9702cb4feb012ddd":null,"_oembed_bfde9e10f59a17b85fc8917fa7edf782":null,"_oembed_time_bfde9e10f59a17b85fc8917fa7edf782":null,"_oembed_03514b67990db061d7c4672de26dc514":null,"_oembed_time_03514b67990db061d7c4672de26dc514":null,"rank_math_news_sitemap_robots":null,"rank_math_robots":null,"_eael_post_view_count":"134","_trp_automatically_translated_slug_ru_ru":null,"_trp_automatically_translated_slug_et":null,"_trp_automatically_translated_slug_lv":null,"_trp_automatically_translated_slug_fr_fr":null,"_trp_automatically_translated_slug_en_us":null,"_wp_old_slug":null,"_trp_automatically_translated_slug_da_dk":null,"_trp_automatically_translated_slug_pl_pl":null,"_trp_automatically_translated_slug_es_es":null,"_trp_automatically_translated_slug_hu_hu":null,"_trp_automatically_translated_slug_fi":null,"_trp_automatically_translated_slug_ja":null,"_trp_automatically_translated_slug_lt_lt":null,"_elementor_edit_mode":null,"_elementor_template_type":null,"_elementor_version":null,"_elementor_pro_version":null,"_wp_page_template":null,"_elementor_page_settings":null,"_elementor_data":null,"_elementor_css":null,"_elementor_conditions":null,"_happyaddons_elements_cache":null,"_oembed_75446120c39305f0da0ccd147f6de9cb":null,"_oembed_time_75446120c39305f0da0ccd147f6de9cb":null,"_oembed_3efb2c3e76a18143e7207993a2a6939a":null,"_oembed_time_3efb2c3e76a18143e7207993a2a6939a":null,"_oembed_59808117857ddf57e478a31d79f76e4d":null,"_oembed_time_59808117857ddf57e478a31d79f76e4d":null,"_oembed_965c5b49aa8d22ce37dfb3bde0268600":null,"_oembed_time_965c5b49aa8d22ce37dfb3bde0268600":null,"_oembed_81002f7ee3604f645db4ebcfd1912acf":null,"_oembed_time_81002f7ee3604f645db4ebcfd1912acf":null,"_elementor_screenshot":null,"_oembed_7ea3429961cf98fa85da9747683af827":null,"_oembed_time_7ea3429961cf98fa85da9747683af827":null,"_elementor_controls_usage":null,"_elementor_page_assets":[],"_elementor_screenshot_failed":null,"theplus_transient_widgets":null,"_eael_custom_js":null,"_wp_old_date":null,"_trp_automatically_translated_slug_it_it":null,"_trp_automatically_translated_slug_pt_pt":null,"_trp_automatically_translated_slug_zh_cn":null,"_trp_automatically_translated_slug_nl_nl":null,"_trp_automatically_translated_slug_pt_br":null,"_trp_automatically_translated_slug_sv_se":null,"rank_math_analytic_object_id":null,"rank_math_internal_links_processed":"1","_trp_automatically_translated_slug_ro_ro":null,"_trp_automatically_translated_slug_sk_sk":null,"_trp_automatically_translated_slug_bg_bg":null,"_trp_automatically_translated_slug_sl_si":null,"litespeed_vpi_list":null,"litespeed_vpi_list_mobile":null,"rank_math_seo_score":null,"rank_math_contentai_score":null,"ilj_limitincominglinks":null,"ilj_maxincominglinks":null,"ilj_limitoutgoinglinks":null,"ilj_maxoutgoinglinks":null,"ilj_limitlinksperparagraph":null,"ilj_linksperparagraph":null,"ilj_blacklistdefinition":null,"ilj_linkdefinition":null,"_eb_reusable_block_ids":null,"rank_math_focus_keyword":"PHP-FPM Slowlog","rank_math_og_content_image":null,"_yoast_wpseo_metadesc":null,"_yoast_wpseo_content_score":null,"_yoast_wpseo_focuskeywords":null,"_yoast_wpseo_keywordsynonyms":null,"_yoast_wpseo_estimated-reading-time-minutes":null,"rank_math_description":null,"surfer_last_post_update":null,"surfer_last_post_update_direction":null,"surfer_keywords":null,"surfer_location":null,"surfer_draft_id":null,"surfer_permalink_hash":null,"surfer_scrape_ready":null,"_thumbnail_id":"20979","footnotes":null,"_links":{"self":[{"href":"https:\/\/webhosting.de\/it\/wp-json\/wp\/v2\/posts\/20986","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/webhosting.de\/it\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/webhosting.de\/it\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/webhosting.de\/it\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/webhosting.de\/it\/wp-json\/wp\/v2\/comments?post=20986"}],"version-history":[{"count":0,"href":"https:\/\/webhosting.de\/it\/wp-json\/wp\/v2\/posts\/20986\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/webhosting.de\/it\/wp-json\/wp\/v2\/media\/20979"}],"wp:attachment":[{"href":"https:\/\/webhosting.de\/it\/wp-json\/wp\/v2\/media?parent=20986"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/webhosting.de\/it\/wp-json\/wp\/v2\/categories?post=20986"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/webhosting.de\/it\/wp-json\/wp\/v2\/tags?post=20986"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}