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

Jak mogę śledzić zapytania MySQL na moim serwerze Linux, gdy się pojawiają?

Na przykład chciałbym skonfigurować jakiś odbiornik, a następnie poprosić o stronę internetową i wyświetlić wszystkie zapytania wykonane przez silnik lub po prostu wyświetlić wszystkie zapytania uruchamiane na serwerze produkcyjnym. W jaki sposób mogę to zrobić?

Możesz uruchomić polecenie MySQL, SHOW FULL PROCESSLIST;aby zobaczyć, jakie zapytania są przetwarzane w danym momencie, ale prawdopodobnie nie osiągniesz tego, na co liczysz.

Najlepszą metodą uzyskania historii bez konieczności modyfikowania każdej aplikacji korzystającej z serwera są prawdopodobnie wyzwalacze. Można skonfigurować wyzwalacze, aby każde uruchomienie zapytania powodowało wstawienie zapytania do jakiejś tabeli historii, a następnie utworzyć osobną stronę, aby uzyskać dostęp do tych informacji.

Pamiętaj jednak, że prawdopodobnie znacznie spowolni to wszystko na serwerze, dodając dodatkowo INSERTdo każdego zapytania.

Edycja: inną alternatywą jest Ogólny dziennik zapytań , ale zapisanie go do płaskiego pliku wyeliminowałoby wiele możliwości elastycznego wyświetlania, szczególnie w czasie rzeczywistym. Jeśli chcesz po prostu prostego, łatwego do wdrożenia sposobu, aby zobaczyć, co się dzieje, włączenie GQL, a następnie użycie uruchamiania tail -fna pliku dziennika załatwi sprawę .

Możesz bardzo łatwo 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';

Wykonuj zapytania (na dowolnym db). Grep lub w inny sposób zbadaj/var/run/mysqld/mysqld.log

Więc nie zapomnij

mysql> SET GLOBAL general_log = 'OFF';

lub wydajność spadnie, a dysk się zapełni!

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

$ mysqladmin -u bob -p -i 1 processlist

Spowoduje to wydrukowanie bieżących zapytań na ekranie co sekundę.

• -u Użytkownik mysql, który chcesz wykonać jako polecenie
• -p Monituj o hasło (więc nie musisz go zapisywać w pliku ani wyświetlać polecenia w historii poleceń)
• i Interwał w sekundach.
• Użyj --verboseflagi, aby wyświetlić pełną listę procesów, wyświetlając całe zapytanie dla każdego procesu. (Dzięki, nmat )

Możliwy jest minus: szybkie zapytania mogą się nie pojawiać, jeśli będą działały między skonfigurowanym interwałem. IE: Mój interwał jest ustawiony na jedną sekundę i jeśli istnieje zapytanie, którego .02uruchomienie zajmuje kilka sekund i jest uruchamiane między interwałami, nie zobaczysz go.

Użyj tej opcji najlepiej, gdy chcesz szybko sprawdzać uruchomione zapytania bez konieczności konfigurowania detektora lub czegokolwiek innego.

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

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

Jedynym haczykiem jest to, że często pomijasz zapytania, które wykonują się bardzo szybko, więc jest to najbardziej przydatne w przypadku zapytań o dłuższym czasie działania lub gdy serwer MySQL zawiera zapytania, których kopie zapasowe są tworzone - z mojego doświadczenia wynika, że ​​właśnie wtedy chcę wyświetlić „ zapytania na żywo.

Możesz także dodać warunki, aby uczynić go bardziej szczegółowym dla dowolnego zapytania SQL.

np. pokazuje wszystkie zapytania działające przez 5 sekund lub dłużej:

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

np. Pokaż wszystkie uruchomione aktualizacje:

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

Aby uzyskać szczegółowe informacje, patrz: 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ływania show list procesów. Dałem z siebie wszystko i wymyśliłem:

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

Uruchom skrypt:

./showsqlprocesslist > showsqlprocesslist.out &

Ogon wyjściowy:

tail -f showsqlprocesslist.out

Bingo bango. Mimo że nie jest dławiony, zajmuje tylko 2-4% procesora na urządzeniach, na których go uruchomiłem. Mam nadzieję, że to może komuś pomóc.

strace

Najszybszym sposobem na sprawdzenie zapytań MySQL / MariaDB na żywo jest użycie debuggera. W systemie Linux możesz użyć stracena przykład:

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

Ponieważ istnieje wiele znaków zmiany znaczenia, możesz sformatować dane wyjściowe strace przez potokowanie (wystarczy dodać |między tymi dwoma liniami) 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"

Powinieneś więc widzieć dość czyste zapytania SQL bez czasu, bez dotykania plików konfiguracyjnych.

Oczywiście nie zastąpi to standardowego sposobu włączania dzienników, który jest opisany poniżej (co wymaga ponownego ładowania serwera SQL).

dtrace

Użyj sond MySQL do przeglądania zapytań MySQL na żywo 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 w pliku (jak watch.d) i uruchom:

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

Dowiedz się więcej: Rozpoczęcie pracy z DTracing MySQL

Gibbs MySQL Spyglass

Zobacz tę odpowiedź .

Kłody

Oto kroki przydatne przy projektowaniu.

Dodaj te linie do swojego ~/.my.cnflub globalnego my.cnf:

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

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

następnie ponownie uruchom MySQL / MariaDB przez (przedrostek, sudojeśli to konieczne):

killall -HUP mysqld

Następnie sprawdź swoje dzienniki:

tail -f /tmp/mysqld.log

Po zakończeniu, zmiany general_logdo 0(dzięki czemu można go używać w przyszłości), a następnie usunąć plik i restart serwera SQL ponownie: killall -HUP mysqld.

To najłatwiejsza konfiguracja na maszynie z systemem Linux Ubuntu, z którą się zetknąłem. Szalony, widząc wszystkie zapytania na żywo.

Znajdź i otwórz 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ć rejestrowanie. Uruchom ponownie MySQL za pomocą tego polecenia:

sudo /etc/init.d/mysql restart

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

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

Teraz uruchom aplikację. Zobaczysz, jak zapytania bazy danych zaczynają latać w oknie terminala. (upewnij się, że masz włączone przewijanie i historię na terminalu)

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

Z wiersza poleceń można uruchomić:

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

Zamień wartości [x] na swoje wartości.

Lub nawet lepiej:

 mysqladmin -u root -p -i 1 processlist;

Sprawdź mtop .

Chciałem zrobić to samo i stworzyłem rozwiązanie z różnych postów, a także stworzyłem małą aplikację konsolową do wyświetlania tekstu zapytania na żywo, gdy jest zapisywany w pliku dziennika. Było to ważne w moim przypadku, ponieważ używam Entity Framework z MySQL i muszę mieć możliwość sprawdzenia wygenerowanego SQL.

Kroki, aby utworzyć plik dziennika (niektóre powielanie innych postów, wszystko dla uproszczenia):

1. Edytuj plik znajdujący się w:

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

   Dodaj „log = development.log” na dole pliku. (Uwaga: zapisanie tego pliku wymagało ode mnie uruchomienia edytora tekstów jako administrator).

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

   Uruchom następujące polecenie, aby włączyć rejestrowanie ogólne, które będzie rejestrować wszystkie uruchomione zapytania:

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

   Spowoduje to, że uruchomione zapytania zostaną zapisane w pliku tekstowym 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 dziennika 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 poprzednich odpowiedzi opisujących, jak włączyć rejestrowanie ogólne, musiałem zmodyfikować jedną dodatkową zmienną w mojej waniliowej instalacji MySql 5.6, zanim jakikolwiek SQL został zapisany w dzienniku:

SET GLOBAL log_output = 'FILE';

Domyślne ustawienie to „BRAK”.

Gibbs MySQL Spyglass

Firma AgilData uruchomiła niedawno narzędzie Gibbs MySQL Scalability Advisor (bezpłatne narzędzie samoobsługowe), które umożliwia użytkownikom przechwytywanie strumienia zapytań na żywo, które należy przesłać do Gibbs. Spyglass (czyli Open Source) będzie obserwował interakcje między Twoimi serwerami MySQL a aplikacjami klienckimi. Nie jest wymagana ponowna konfiguracja ani restartowanie serwera bazy danych MySQL (klienta ani aplikacji).

GitHub: AgilData / gibbs-mysql-spyglass

Dowiedz się więcej: Przechwytywanie pakietów MySQL za pomocą Rust

Polecenie instalacji:

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