Come posso visualizzare le query live di MySQL?

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?

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.

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à!

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.

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

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.

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.

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/

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;

Dai un'occhiata a mtop .

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);
           }
       }
     }
   }

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'.

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