Come posso visualizzare le query live di MySQL?


493

Come posso tracciare le query MySQL sul mio server Linux mentre si verificano?

Ad esempio, mi piacerebbe impostare una sorta di listener, quindi richiedere una pagina Web e visualizzare tutte le query eseguite dal motore o semplicemente visualizzare tutte le query in esecuzione su un server di produzione. Come posso fare questo?


A seconda di quanto sia grave un problema, consiglio vivamente di provare MySql Proxy. B / c può essere posizionato sul server delle app, a) è scalabile, b) non deve influenzare tutto il traffico verso il db. È in "alpha", ma è in circolazione da molto tempo. dev.mysql.com/downloads/mysql-proxy
Jeff Maass

15
Perché è stato chiuso ?! Sta chiedendo come fare X , non per una raccomandazione. Quasi 200 persone hanno trovato utile questa domanda. Le mod devono calmarsi.
Cerin,

1
Ho riformulato questa domanda per omettere qualsiasi riferimento agli strumenti. Penso che questa domanda sia perfettamente in tema qui, in quanto "stiamo eseguendo le query che dovremmo essere?" è un ottimo primo passo nel debug di un problema relativo al database.
Jeffrey Bosboom,

1
Il proxy mysql @MaasSql non è utile per gli sviluppatori php durante l'utilizzo di PDO poiché la query e i valori vengono associati solo al server.
Ananda,

Risposte:


300

Puoi eseguire il comando MySQL SHOW FULL PROCESSLIST;per vedere quali query vengono elaborate in qualsiasi momento, ma probabilmente non raggiungeranno ciò che speri.

Il metodo migliore per ottenere una cronologia senza dover modificare ogni applicazione che utilizza il server è probabilmente tramite i trigger. È possibile impostare i trigger in modo che ogni esecuzione della query comporti l'inserimento della query in una sorta di tabella della cronologia, quindi creare una pagina separata per accedere a queste informazioni.

Tieni presente che probabilmente questo rallenterà considerevolmente tutto sul server, con l'aggiunta di un extra INSERTin cima a ogni singola query.


Modifica: un'altra alternativa è il registro generale delle query , ma averlo scritto in un file semplice rimuoverà molte possibilità di flessibilità di visualizzazione, soprattutto in tempo reale. Se vuoi solo un modo semplice e facile da implementare per vedere cosa sta succedendo, abilitare GQL e quindi usare l'esecuzione tail -fsul file di registro farebbe il trucco.


5
Può sembrare sciocco ma come posso abilitare esattamente GQL? Ho aggiunto log_output = file, general_log = 1 e general_log_file = / pathtofile, e ho adattato il file di registro, ho colpito il sito e non ho ottenuto nulla. Che cosa sto facendo di sbagliato?
barfoon,

Non posso essere sicuro di nulla, ma assicurati di aver riavviato il server e anche che il file che hai scelto è uno a cui mysql avrebbe accesso in scrittura.
Chad Birch,

7
L'ho capito - tutto ciò di cui avevo bisogno in my.cnf era log = / path / to / log Poi ho appena fatto la coda e visualizza tutte le query.
barfoon,

1
Per quanto ne so, non c'è modo di innescare nulla su un'istruzione SELECT. I trigger si applicano solo a INSERT, UPDATE, DELETE ... o sono male informato?
gabe.

1
Ero nello stesso posto prima. Attualmente sto usando Monyog che fa tutto questo con un sovraccarico molto minore, quindi nulla rallenta.

520

Puoi registrare ogni query in un file di registro molto facilmente:

mysql> SHOW VARIABLES LIKE "general_log%";

+------------------+----------------------------+
| Variable_name    | Value                      |
+------------------+----------------------------+
| general_log      | OFF                        |
| general_log_file | /var/run/mysqld/mysqld.log |
+------------------+----------------------------+

mysql> SET GLOBAL general_log = 'ON';

Fai le tue domande (su qualsiasi db). Grep o altrimenti esaminare/var/run/mysqld/mysqld.log

Quindi non dimenticare di

mysql> SET GLOBAL general_log = 'OFF';

o le prestazioni crolleranno e il tuo disco si riempirà!


37
Buona risposta! È possibile utilizzare tail -f -n300 /var/run/mysqld/mysqld.logper tenere traccia in tempo reale del file di registro
Claudio Bredfeldt,

4
Nota che per queste variabili è necessario MySQL 5.1.12 o versioni successive. Prima di ciò, dovresti riavviare MySQL per modificare queste impostazioni.
jlh

Esiste un modo per ottenere le variabili con parametri scritte nel registro? Sto vedendo SELECT name FROM person where id=?ma non so cosa idsia.
Jeff,

SHOW VARIABLESnon ha funzionato per me. Comunque SELECT @@GLOBAL.general_log_file;funziona benissimo. (MariaDB 10.1.9)
phil pirozhkov,

1
importante : è necessario verificare l'output della registrazione con SHOW VARIABLES LIKE "log_output%". Se impostato su table, i log verranno salvati nel database stesso, tabella mysql.general_lognon nel file system. Puoi cambiarlo file conSET GLOBAL log_output = 'file';
Arnis Juraga il

199

Anche se una risposta è già stata accettata, vorrei presentare quella che potrebbe anche essere l'opzione più semplice:

$ mysqladmin -u bob -p -i 1 processlist

Questo stamperà le query correnti sullo schermo ogni secondo.

  • -u L'utente mysql che si desidera eseguire il comando come
  • -p Richiedi la password (quindi non è necessario salvarla in un file o visualizzare il comando nella cronologia dei comandi)
  • i L'intervallo in secondi.
  • Utilizzare il --verboseflag per mostrare l'elenco completo dei processi, visualizzando l'intera query per ciascun processo. (Grazie, nmat )

C'è un possibile aspetto negativo: le query rapide potrebbero non essere visualizzate se vengono eseguite nell'intervallo impostato. IE: il mio intervallo è impostato su un secondo e se esiste una query che richiede .02secondi per l'esecuzione e viene eseguita tra intervalli, non lo vedrai.

Utilizzare questa opzione preferibilmente quando si desidera verificare rapidamente l'esecuzione di query senza dover impostare un listener o altro.


11
QUESTA è la soluzione migliore!
user1398287

3
A mio avviso, questa soluzione migliore perché non utilizzare una nuova connessione mysql per inviare il comando ogni volta, invece aprire una connessione mysql e utilizzarla per inviare la process list show;
Jose Nobile,

@JoseNobile Se si mantiene aperta la connessione mysql nell'adattatore, non importa. La mia soluzione non è esattamente adatta per OP perché la mia soluzione non è pronta per l'uso in un adattatore. È, tuttavia, semplice e veloce.
halfpastfour.am

7
Puoi aggiungere --verboseper vedere le query complete
nmat

2
Questa è la risposta che stavo cercando. Dovrebbe essere accettato come risposta. È anche la risposta più semplice da implementare.
Ciad

51

Esegui questa comoda query SQL per vedere l'esecuzione di query MySQL. Può essere eseguito da qualsiasi ambiente che ti piace, quando vuoi, senza modifiche al codice o spese generali. Potrebbe richiedere una configurazione delle autorizzazioni di MySQL, ma per me funziona solo senza alcuna configurazione speciale.

SELECT * FROM INFORMATION_SCHEMA.PROCESSLIST WHERE COMMAND != 'Sleep';

L'unico problema è che spesso ti mancano le query che vengono eseguite molto rapidamente, quindi è molto utile per le query più lunghe o quando il server MySQL ha query che eseguono il backup. Nella mia esperienza, questo è esattamente il momento in cui voglio visualizzare " query "dal vivo.

È inoltre possibile aggiungere condizioni per renderlo più specifico solo per qualsiasi query SQL.

ad es. Mostra tutte le query in esecuzione per almeno 5 secondi:

SELECT * FROM INFORMATION_SCHEMA.PROCESSLIST WHERE COMMAND != 'Sleep' AND TIME >= 5;

ad esempio Mostra tutti gli AGGIORNAMENTI in esecuzione:

SELECT * FROM INFORMATION_SCHEMA.PROCESSLIST WHERE COMMAND != 'Sleep' AND INFO LIKE '%UPDATE %';

Per i dettagli completi, consultare: http://dev.mysql.com/doc/refman/5.1/en/processlist-table.html


17

Sono in una situazione particolare in cui non ho le autorizzazioni per attivare la registrazione e non avrei le autorizzazioni per visualizzare i registri se fossero attivi. Non ho potuto aggiungere un trigger, ma avevo le autorizzazioni per chiamare show processlist. Quindi, ho fatto del mio meglio e ho pensato a questo:

Crea uno script bash chiamato "showsqlprocesslist":

#!/bin/bash

while [ 1 -le 1 ]
do
         mysql --port=**** --protocol=tcp --password=**** --user=**** --host=**** -e "show processlist\G" | grep Info | grep -v processlist | grep -v "Info: NULL";
done

Esegui lo script:

./showsqlprocesslist > showsqlprocesslist.out &

Coda l'output:

tail -f showsqlprocesslist.out

Bingo Bango. Anche se non è strozzato, ha impiegato solo il 2-4% di CPU sulle scatole su cui l'ho eseguito. Spero che forse questo aiuti qualcuno.


Ha! Delizioso. Lo adoro.
Darth Egregious,

È necessario un certo ritardo per evitare un output troppo dettagliato. Vedi la mia modifica per favore.
Slyx,

@Slyx grazie per il suggerimento di mettere un sonno nel loop. Tuttavia, se stai cercando query di breve durata che vivano per meno tempo del sonno, potresti perdere ciò che stai cercando. Se stai davvero cercando un'istantanea in tempo, questo non dovrebbe essere eseguito in un ciclo. Va anche notato che questo potrebbe potenzialmente perdere domande di breve durata.
Michael Krauklis,

17

strace

Il modo più rapido per visualizzare le query live di MySQL / MariaDB è utilizzare il debugger. Su Linux puoi usare strace, ad esempio:

sudo strace -e trace=read,write -s 2000 -fp $(pgrep -nf mysql) 2>&1

Dato che ci sono molti caratteri di escape, è possibile che il formato di output di strace per tubazioni (basta aggiungere |tra queste due battute) sopra nel seguente comando:

grep --line-buffered -o '".\+[^"]"' | grep --line-buffered -o '[^"]*[^"]' | while read -r line; do printf "%b" $line; done | tr "\r\n" "\275\276" | tr -d "[:cntrl:]" | tr "\275\276" "\r\n"

Quindi dovresti vedere query SQL abbastanza pulite senza tempo, senza toccare i file di configurazione.

Ovviamente questo non sostituirà il modo standard di abilitare i log, che è descritto di seguito (che comporta il ricaricamento del server SQL).

dtrace

Utilizzare le sonde MySQL per visualizzare le query MySQL live senza toccare il server. Script di esempio:

#!/usr/sbin/dtrace -q
pid$target::*mysql_parse*:entry /* This probe is fired when the execution enters mysql_parse */
{
     printf("Query: %s\n", copyinstr(arg1));
}

Salvare lo script sopra in un file (come watch.d) ed eseguire:

pfexec dtrace -s watch.d -p $(pgrep -x mysqld)

Ulteriori informazioni: Introduzione a DTracing MySQL

Gibbs MySQL Spyglass

Vedere questo risposta .

logs

Ecco i passaggi utili per le proposte di sviluppo.

Aggiungi queste righe al tuo ~/.my.cnfo globale my.cnf:

[mysqld]
general_log=1
general_log_file=/tmp/mysqld.log

Percorsi: /var/log/mysqld.logo /usr/local/var/log/mysqld.logpuò anche funzionare a seconda delle autorizzazioni del file.

quindi riavvia MySQL / MariaDB (prefisso con sudose necessario):

killall -HUP mysqld

Quindi controlla i tuoi registri:

tail -f /tmp/mysqld.log

Dopo che il rivestimento, il cambiamento general_logdi 0(in modo da poter utilizzare in futuro), quindi rimuovere il file e riavviare il server SQL di nuovo: killall -HUP mysqld.


1
Non è necessario uccidere il server se si imposta general_logda una query MySQL. Inizierà a scrivere nel file a cui general_log_filepunta.
Robert Brisita,

15

Questa è la configurazione più semplice su una macchina Ubuntu Linux che ho incontrato. Pazzo di vedere tutte le domande dal vivo.

Trova e apri il tuo file di configurazione MySQL, di solito /etc/mysql/my.cnf su Ubuntu. Cerca la sezione che dice "Registrazione e replica"

#
# * Logging and Replication
#
# Both location gets rotated by the cronjob.
# Be aware that this log type is a performance killer.

log = /var/log/mysql/mysql.log

Basta decommentare la variabile "log" per attivare la registrazione. Riavvia MySQL con questo comando:

sudo /etc/init.d/mysql restart

Ora siamo pronti per iniziare a monitorare le query non appena arrivano. Apri un nuovo terminale ed esegui questo comando per scorrere il file di registro, modificando il percorso se necessario.

tail -f /var/log/mysql/mysql.log

Ora esegui la tua applicazione. Vedrai le query del database iniziare a volare nella finestra del tuo terminale. (assicurati di avere lo scorrimento e la cronologia abilitati sul terminale)

DA http://www.howtogeek.com/howto/database/monitor-all-sql-queries-in-mysql/


13

Da una riga di comando è possibile eseguire:

watch --interval=[your-interval-in-seconds] "mysqladmin -u root -p[your-root-pw] processlist | grep [your-db-name]"

Sostituisci i valori [x] con i tuoi valori.

O ancora meglio:

 mysqladmin -u root -p -i 1 processlist;

1
Questo è in realtà un ottimo frammento che potrebbe tornare utile .. Grazie!
MGP

esattamente quello che stavo cercando !! l'orologio deve essere installato separatamente.
Tilo,

12

Dai un'occhiata a mtop .


1
Sì, ma buona fortuna installandolo su Debian o Ubuntu: bugs.launchpad.net/ubuntu/+source/mtop/+bug/77980
mlissner

Gestito per farlo funzionare su debian, ma è un po 'inutile poiché manca molte domande. Riesco a vedere il contatore delle query che sale costantemente ma raramente visualizza eventuali query. Sembra che visualizza solo le query che richiedono più di circa 1 secondo.
Cobra_Fast,

@Cobra_Fast è chiaramente indicato sulla pagina mfor Sourceforge: mtop (MySQL top) monitors a MySQL server showing the queries which are taking the most amount of time to complete. mtop.sourceforge.net A volte è abbastanza utile.
Ian Lewis,

7

Ho cercato di fare lo stesso e ho messo insieme una soluzione da vari post, oltre a creare una piccola app console per produrre il testo della query live mentre viene scritto nel file di registro. Questo è stato importante nel mio caso poiché sto usando Entity Framework con MySQL e devo essere in grado di ispezionare l'SQL generato.

I passaggi per creare il file di registro (alcuni duplicati di altri post, tutti qui per semplicità):

  1. Modifica il file che si trova in:

    C:\Program Files (x86)\MySQL\MySQL Server 5.5\my.ini

    Aggiungi "log = development.log" nella parte inferiore del file. (Nota che il salvataggio di questo file mi ha richiesto di eseguire il mio editor di testo come amministratore).

  2. Usa MySql workbench per aprire una riga di comando, inserisci la password.

    Eseguire quanto segue per attivare la registrazione generale che registra tutte le query eseguite:

    SET GLOBAL general_log = 'ON';
    
    To turn off:
    
    SET GLOBAL general_log = 'OFF';

    Ciò farà sì che le query in esecuzione vengano scritte in un file di testo nella seguente posizione.

    C:\ProgramData\MySQL\MySQL Server 5.5\data\development.log
  3. Crea / Esegui un'app console che produrrà le informazioni del registro in tempo reale:

    Fonte disponibile per il download qui

    Fonte:

    using System;
    using System.Configuration;
    using System.IO;
    using System.Threading;
    
    namespace LiveLogs.ConsoleApp
    {
      class Program
      {
        static void Main(string[] args)
        {
            // Console sizing can cause exceptions if you are using a 
            // small monitor. Change as required.
    
            Console.SetWindowSize(152, 58);
            Console.BufferHeight = 1500;
    
            string filePath = ConfigurationManager.AppSettings["MonitoredTextFilePath"];
    
            Console.Title = string.Format("Live Logs {0}", filePath);
    
            var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
    
            // Move to the end of the stream so we do not read in existing
            // log text, only watch for new text.
    
            fileStream.Position = fileStream.Length;
    
            StreamReader streamReader;
    
            // Commented lines are for duplicating the log output as it's written to 
            // allow verification via a diff that the contents are the same and all 
            // is being output.
    
            // var fsWrite = new FileStream(@"C:\DuplicateFile.txt", FileMode.Create);
            // var sw = new StreamWriter(fsWrite);
    
            int rowNum = 0;
    
            while (true)
            {
                streamReader = new StreamReader(fileStream);
    
                string line;
                string rowStr;
    
                while (streamReader.Peek() != -1)
                {
                    rowNum++;
    
                    line = streamReader.ReadLine();
                    rowStr = rowNum.ToString();
    
                    string output = String.Format("{0} {1}:\t{2}", rowStr.PadLeft(6, '0'), DateTime.Now.ToLongTimeString(), line);
    
                    Console.WriteLine(output);
    
                    // sw.WriteLine(output);
                }
    
                // sw.Flush();
    
                Thread.Sleep(500);
            }
        }
      }
    }

1
Questo sembra davvero fantastico e sicuramente lo darò a un'occhiata, sarò fantastico prenderlo come progetto OSS e creare uno strumento di profilazione!
Rippo,

Penso che sia una buona idea. Ho inserito un repository SVN sul codice google. Probabilmente il progetto OS più piccolo di sempre, ma finora è stato molto utile. Probabilmente lo estenderò, sarei interessato a vedere se qualcun altro lo porta oltre. code.google.com/p/livelogs
gb2d

OP ha bisogno che funzioni sulla sua macchina Linux. Sembra che la tua risposta sia pensata per un computer Windows. Sebbene questa risposta rifletta la creatività, potrebbe non essere utile per gli altri.
halfpastfour.am

1

Oltre alle risposte precedenti che descrivono come abilitare la registrazione generale, ho dovuto modificare una variabile aggiuntiva nella mia installazione MySQL 5 di Vanilla prima che qualsiasi SQL fosse scritto nel registro:

SET GLOBAL log_output = 'FILE';

L'impostazione predefinita era 'NONE'.


0

Gibbs MySQL Spyglass

AgilData ha lanciato di recente il MySQL Scalability Advisor di Gibbs (uno strumento self-service gratuito) che consente agli utenti di acquisire un flusso live di query da caricare su Gibbs. Spyglass (che è Open Source) controllerà le interazioni tra i server MySQL e le applicazioni client. Non è necessaria alcuna riconfigurazione o riavvio del server di database MySQL (client o app).

GitHub: AgilData / gibbs-mysql-spyglass

Ulteriori informazioni: Pacchetto che cattura MySQL con Rust

Comando di installazione:

curl -s https://raw.githubusercontent.com/AgilData/gibbs-mysql-spyglass/master/install.sh | bash

2
Spyglass sembra richiedere una chiave API da un server inattivo e l'ultimo commit è stato 3 anni fa. Non sono sicuro che questo prodotto sia ancora supportato / funzionante.
Dan Tenenbaum,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.