Jak mogę wyświetlić na żywo zapytania MySQL?

Możesz w prosty sposób zapisać każde zapytanie do pliku dziennika:

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

Wykonaj swoje zapytania(na dowolnym db). Grep lub w inny sposób zbadać /var/run/mysqld/mysqld.log

Then don ' t forget to

mysql> SET GLOBAL general_log = 'OFF';

Albo wydajność spadnie i twój dysk zapełni się!

Mimo, że odpowiedź została już zaakceptowana, chciałbym przedstawić to, co może być nawet najprostszą opcją:

$ mysqladmin -u bob -p -i 1 processlist

Wyświetli bieżące zapytania na ekranie co sekundę.

• -u użytkownik mysql, który ma wykonać polecenie jako
• -p poproś o hasło (nie musisz zapisywać go w pliku ani wyświetlać polecenia w historii poleceń)
• i interwał w sekundach.
• Użyj flagi --verbose, aby pokazać pełna lista procesów, wyświetlająca całe zapytanie dla każdego procesu. (Dzięki, nmat )

Istnieje możliwy minus: szybkie zapytania mogą nie pojawić się, jeśli działają między ustawionym interwałem. IE: mój interwał jest ustawiony na jedną sekundę i jeśli istnieje zapytanie, które trwa .02 sekund i jest uruchamiane między interwałami, nie zobaczysz go.

Użyj tej opcji najlepiej, gdy chcesz szybko sprawdzić uruchomione zapytania bez konieczności konfigurowania listenera lub cokolwiek innego.

Uruchom to wygodne zapytanie SQL, aby zobaczyć uruchomione zapytania MySQL. Może być uruchamiany z dowolnego środowiska, kiedy tylko chcesz, bez żadnych zmian kodu lub kosztów ogólnych. Może wymagać konfiguracji uprawnień MySQL, ale dla mnie działa bez specjalnej konfiguracji.

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

Jedynym haczykiem jest to, że często brakuje zapytań, które wykonują się bardzo szybko, więc jest to najbardziej przydatne w przypadku zapytań dłuższych lub gdy serwer MySQL ma zapytania, które są kopie zapasowe - z mojego doświadczenia jest to dokładnie wtedy, gdy chcę wyświetlić zapytania "NA ŻYWO".

Możesz również dodać warunki, aby było bardziej szczegółowe dla każdego zapytania SQL.

Np. pokazuje wszystkie zapytania działające przez 5 sekund lub więcej:

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

Np. Pokaż wszystkie bieżące aktualizacje:

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

Szczegółowe informacje znajdują się na stronie: http://dev.mysql.com/doc/refman/5.1/en/processlist-table.html

Jestem w szczególnej sytuacji, w której nie mam uprawnień do włączania logowania i nie miałbym uprawnień do przeglądania dzienników, gdyby były włączone. Nie mogłem dodać wyzwalacza, ale miałem uprawnienia do wywołania show processlist. Więc, dałem z siebie wszystko i wymyśliłem to:

Utwórz skrypt bash o nazwie "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

Wykonaj skrypt:

./showsqlprocesslist > showsqlprocesslist.out &

Ogon wyjścia:

tail -f showsqlprocesslist.out

Jest to najprostsza konfiguracja na komputerze z systemem Linux Ubuntu, na którą natknąłem się. Crazy to see all the queries live.

Znajdź i otwórz swój plik konfiguracyjny MySQL, Zwykle /etc / mysql / my.cnf na Ubuntu. Poszukaj sekcji "Logowanie i replikacja"

#
# * 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

Po prostu odkomentuj zmienną "log", aby włączyć logowanie. Uruchom ponownie MySQL za pomocą tego polecenia:

sudo /etc/init.d/mysql restart

Teraz jesteśmy gotowi do rozpoczęcia monitorowania zapytań w miarę ich pojawiania się. Otwórz nowy terminal i uruchom to polecenie, aby przewiń plik dziennika, dostosowując ścieżkę w razie potrzeby.

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

Teraz uruchom aplikację. W oknie terminala pojawią się zapytania do bazy danych. (upewnij się, że przewijanie i historia są włączone na terminalu)

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

Z linii poleceń można uruchomić:

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

Zastąp wartości [x] swoimi wartościami.

Albo nawet lepiej:

 mysqladmin -u root -p -i 1 processlist;

Sprawdź mtop .

strace

Najszybszym sposobem wyświetlania na żywo zapytań MySQL / MariaDB jest użycie debuggera. Na Linuksie możesz użyć strace, na przykład:

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

Ponieważ istnieje wiele znaków, możesz sformatować wyjście strace ' a przez Orurowanie (wystarczy dodać | pomiędzy tymi dwoma jednowierszowcami) powyżej do następującego polecenia:

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"

Więc powinieneś zobaczyć dość czyste zapytania SQL bez dotykania plików konfiguracyjnych.

Oczywiście, że nie zastąpienie opisanego poniżej standardowego sposobu włączania logów (który polega na przeładowaniu serwera SQL).

dtrace

Użyj sond MySQL, aby wyświetlić bieżące zapytania MySQL bez dotykania serwera. Przykładowy skrypt:

#!/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));
}

Zapisz powyższy skrypt do pliku (jak watch.d) i uruchom:

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

Dowiedz się więcej: pierwsze kroki z Dtracingiem MySQL

Rdza

AgilData uruchomiła niedawno Gibbs MySQL Scalability Advisor (a darmowe narzędzie samoobsługowe), które umożliwia użytkownikom przechwytywanie strumienia zapytań na żywo, które mają być przesłane do Gibbsa. Spyglass (który jest Open Source) będzie obserwować interakcje między serwerami MySQL i aplikacjami klienckimi. Nie jest wymagana rekonfiguracja ani restart serwera bazy danych MySQL (klienta lub aplikacji).

GitHub: AgilData / gibbs-mysql-spyglass

Dowiedz się więcej: Przechwytywanie pakietu MySQL za pomocą Rusta

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

Logi

Oto kroki przydatne dla rozwoju proponuje.

Dodaj te linie do twojego ~/.my.cnf lub globalnego my.cnf:

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

_{ścieżki: /var/log/mysqld.log lub /usr/local/var/log/mysqld.log mogą również działać w zależności od uprawnień do plików.}

Następnie uruchom ponownie MySQL / MariaDB przez (prefiks z sudo w razie potrzeby):

killall -HUP mysqld

Następnie sprawdź swoje logi:

tail -f /tmp/mysqld.log

Po zakończeniu Zmień general_log na 0 (dzięki czemu możesz go używać w przyszłości), następnie usuń plik i uruchom ponownie SQL server: killall -HUP mysqld.

Szukałem tego samego i połączyłem rozwiązanie z różnych postów, a także stworzyłem małą aplikację konsolową, która wyświetla tekst zapytania NA ŻYWO, który jest zapisany w pliku dziennika. Było to ważne w moim przypadku, ponieważ używam encji Framework z MySQL i muszę być w stanie sprawdzić wygenerowany SQL.

Kroki tworzenia pliku dziennika (powielanie innych postów, wszystko tutaj dla uproszczenia):

1. Edytuj plik znajdujący się pod adresem:

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

   Dodaj "log = rozwój.log " na dole pliku. (Uwaga zapisanie tego pliku wymagało ode mnie uruchomienia edytora tekstu jako administratora).

2. Użyj MySql workbench, aby otworzyć wiersz poleceń, wprowadź hasło.

   Uruchom następujące, aby włączyć ogólne logowanie, które zarejestruje wszystkie zapytania uruchomione:

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

   Spowoduje to, że uruchomione zapytania będą zapisywane do pliku tekstowego w następującej lokalizacji.

   C:\ProgramData\MySQL\MySQL Server 5.5\data\development.log
   

3. Utwórz / Uruchom aplikację konsoli, która wyświetli informacje o dzienniku w czasie rzeczywistym:

   Źródło dostępne do pobrania tutaj

   Źródło:

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

Oprócz wcześniejszych odpowiedzi opisujących jak włączyć ogólne logowanie, musiałem zmodyfikować jedną dodatkową zmienną w mojej instalacji vanilla MySql 5.6 zanim jakikolwiek SQL został zapisany do dziennika:

SET GLOBAL log_output = 'FILE';

Domyślnym ustawieniem było 'NONE'.