it-swarm.com.de

Wie kann ich MySQL-Abfragen live anzeigen?

Wie kann ich MySQL-Abfragen auf meinem Linux-Server nachverfolgen?

Zum Beispiel würde ich gerne eine Art Listener einrichten, dann eine Webseite anfordern und alle Abfragen anzeigen, die von der Engine ausgeführt werden, oder einfach alle Abfragen, die auf einem Produktionsserver ausgeführt werden. Wie kann ich das machen?

431
barfoon

Sie können den MySQL-Befehl SHOW FULL PROCESSLIST; ausführen, um zu sehen, welche Abfragen zu einem bestimmten Zeitpunkt verarbeitet werden. Dies wird jedoch wahrscheinlich nicht das erreichen, worauf Sie hoffen.

Die beste Methode, um eine Historie abzurufen, ohne dass jede Anwendung, die den Server verwendet, geändert werden muss, ist wahrscheinlich durch Trigger. Sie können Trigger so einrichten, dass bei jeder Abfrageausführung die Abfrage in eine Art Verlaufstabelle eingefügt wird. Anschließend können Sie eine separate Seite erstellen, um auf diese Informationen zuzugreifen.

Beachten Sie jedoch, dass dies wahrscheinlich alles auf dem Server erheblich verlangsamen wird, indem Sie zusätzlich zu jeder einzelnen Abfrage eine INSERT hinzufügen.


Bearbeiten: Eine andere Alternative ist das General Query Log , aber wenn es in eine flache Datei geschrieben wird, würde dies eine Vielzahl von Möglichkeiten für die Anzeige von Flexibilität bedeuten, insbesondere in Echtzeit. Wenn Sie nur eine einfache, einfach zu implementierende Methode suchen möchten, um zu sehen, was passiert, können Sie GQL aktivieren und dann tail -f für die Protokolldatei ausführen, um den Trick auszuführen.

258
Chad Birch

Sie können jede Abfrage ganz einfach in einer Protokolldatei protokollieren:

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

Stellen Sie Ihre Fragen (auf einer beliebigen Datenbank). Grep oder anderweitig prüfen /var/run/mysqld/mysqld.log 

Dann vergiss es nicht 

mysql> SET GLOBAL general_log = 'OFF';

oder die Leistung sinkt und Ihre Festplatte wird gefüllt!

460
artfulrobot

Obwohl eine Antwort bereits akzeptiert wurde, möchte ich Ihnen die vielleicht einfachste Möglichkeit vorstellen:

$ mysqladmin -u bob -p -i 1 processlist

Dadurch werden die aktuellen Abfragen jede Sekunde auf Ihrem Bildschirm gedruckt.

  • -u Der mysql-Benutzer, unter dem Sie den Befehl ausführen möchten
  • -p Sie werden aufgefordert, Ihr Kennwort einzugeben (damit Sie es nicht in einer Datei speichern müssen oder der Befehl in Ihrem Befehlsverlauf angezeigt wird.)
  • i Das Intervall in Sekunden.
  • Verwenden Sie das Flag --verbose, um die vollständige Prozessliste anzuzeigen und die gesamte Abfrage für jeden Prozess anzuzeigen. (Danke, nmat )

Es gibt einen möglichen Nachteil: Schnelle Abfragen werden möglicherweise nicht angezeigt, wenn sie zwischen dem von Ihnen festgelegten Intervall ausgeführt werden. IE: Mein Intervall ist auf eine Sekunde festgelegt. Wenn eine Abfrage ausgeführt wird, die .02 Sekunden dauert und zwischen Intervallen ausgeführt wird, wird sie nicht angezeigt.

Verwenden Sie diese Option vorzugsweise, wenn Sie schnell prüfen möchten, ob Abfragen ausgeführt werden, ohne einen Listener oder etwas anderes einrichten zu müssen.

163
halfpastfour.am

Führen Sie diese praktische SQL-Abfrage aus, um die laufenden MySQL-Abfragen anzuzeigen. Es kann von jeder beliebigen Umgebung aus ausgeführt werden, wann immer Sie möchten, ohne Codeänderungen oder Zusatzkosten. Es erfordert möglicherweise einige MySQL-Berechtigungskonfigurationen, aber für mich läuft es einfach ohne spezielle Einstellungen.

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

Der einzige Haken ist, dass Sie häufig Abfragen verpassen, die sehr schnell ausgeführt werden. Dies ist besonders nützlich für länger laufende Abfragen oder wenn der MySQL-Server Abfragen hat, die gesichert werden. Dies ist meiner Meinung nach genau der Zeitpunkt, zu dem ich " Live-Anfragen.

Sie können auch Bedingungen hinzufügen, um nur jede SQL-Abfrage spezifischer zu machen.

z.B. Zeigt alle Abfragen, die 5 Sekunden oder länger laufen:

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

z.B. Alle laufenden UPDATEs anzeigen:

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

Für vollständige Details siehe: http://dev.mysql.com/doc/refman/5.1/de/processlist-table.html

38
python1981

Ich befinde mich in einer bestimmten Situation, in der ich keine Berechtigungen zum Aktivieren der Protokollierung habe und keine Berechtigungen zum Anzeigen der Protokolle haben würde, wenn sie aktiviert wären. Ich konnte keinen Auslöser hinzufügen, hatte jedoch die Berechtigung, show processlist aufzurufen. Also gab ich mir die beste Mühe und kam dazu:

Erstellen Sie ein Bash-Skript mit dem Namen "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

Führen Sie das Skript aus:

./showsqlprocesslist > showsqlprocesslist.out &

Tail die Ausgabe:

tail -f showsqlprocesslist.out

Bingo Bango. Obwohl es nicht gedrosselt ist, verbrauchte es nur 2-4% CPU für die Boxen, auf denen ich es ausgeführt habe. Ich hoffe vielleicht hilft das jemandem.

16

Dies ist das einfachste Setup auf einem Linux-Ubuntu-Computer, dem ich begegnet bin. Verrückt, alle Anfragen live zu sehen.

Suchen und öffnen Sie Ihre MySQL-Konfigurationsdatei (normalerweise /etc/mysql/my.cnf auf Ubuntu). Suchen Sie nach dem Abschnitt "Protokollierung und Replikation".

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

Kommentieren Sie einfach die Variable "log", um die Protokollierung zu aktivieren. Starten Sie MySQL mit diesem Befehl neu:

Sudo /etc/init.d/mysql restart

Jetzt können Sie mit der Überwachung der eingehenden Abfragen beginnen. Öffnen Sie ein neues Terminal und führen Sie diesen Befehl aus, um die Protokolldatei zu scrollen und den Pfad ggf. anzupassen.

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

Führen Sie jetzt Ihre Anwendung aus. Die Datenbankabfragen werden in Ihrem Terminalfenster angezeigt. (Stellen Sie sicher, dass auf dem Terminal Bildlauf und Verlauf aktiviert sind.)

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

15
Wil

strace

Der schnellste Weg, Live-MySQL/MariaDB-Abfragen anzuzeigen, ist der Debugger. Unter Linux können Sie strace verwenden, zum Beispiel:

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

Da es viele Zeichen mit Escapezeichen gibt, können Sie die Ausgabe von strace von piping (fügen Sie einfach | zwischen diesen beiden Einzeilen) oben in den folgenden Befehl ein:

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"

Sie sollten also relativ saubere SQL-Abfragen ohne Zeitaufwand sehen, ohne Konfigurationsdateien zu berühren.

Offensichtlich ersetzt dies nicht die Standardmethode zum Aktivieren von Protokollen, die im Folgenden beschrieben wird (was ein erneutes Laden des SQL-Servers beinhaltet).

dtrace

Verwenden Sie MySQL-Tests, um die Live-MySQL-Abfragen anzuzeigen, ohne den Server zu berühren. Beispielskript:

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

Speichern Sie das obige Skript in einer Datei (wie watch.d) und führen Sie Folgendes aus:

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

Weitere Informationen: Erste Schritte mit DTracing MySQL

Gibbs MySQL Spyglass

Siehe diese Antwort .

Protokolle

Hier sind die Schritte, die für Entwicklungsvorschläge nützlich sind.

Fügen Sie diese Zeilen in Ihren ~/.my.cnf oder globalen my.cnf ein:

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

Die Pfade: /var/log/mysqld.log oder /usr/local/var/log/mysqld.log funktionieren möglicherweise ebenfalls abhängig von Ihren Dateiberechtigungen.

starten Sie dann Ihr MySQL/MariaDB neu mit (ggf. Präfix mit Sudo):

killall -HUP mysqld

Dann überprüfen Sie Ihre Protokolle:

tail -f /tmp/mysqld.log

Ändern Sie nach Abschluss general_log in 0 (damit Sie sie zukünftig verwenden können), entfernen Sie die Datei und starten Sie den SQL-Server erneut: killall -HUP mysqld.

15
kenorb

Von einer Befehlszeile aus könnten Sie Folgendes ausführen:

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

Ersetzen Sie die Werte [x] durch Ihre Werte.

Oder noch besser: 

 mysqladmin -u root -p -i 1 processlist;
13
recurse

Check out mtop .

11
Chris KL

Ich habe versucht, das gleiche zu tun, und habe eine Lösung aus verschiedenen Beiträgen zusammengeschustert sowie eine kleine Konsolen-App erstellt, um den Live-Abfragetext auszugeben, während er in die Protokolldatei geschrieben wird. Dies war in meinem Fall wichtig, da ich Entity Framework mit MySQL verwende und die generierte SQL überprüfen muss.

Schritte zum Erstellen der Protokolldatei (einige Duplikate anderer Beiträge, alle hier der Einfachheit halber):

  1. Bearbeiten Sie die Datei unter:

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

    Fügen Sie "log = development.log" am Ende der Datei hinzu. (Beim Speichern dieser Datei musste ich meinen Texteditor als Administrator ausführen.).

  2. Öffnen Sie in einer MySql-Workbench eine Befehlszeile, und geben Sie das Kennwort ein.

    Führen Sie die folgenden Schritte aus, um die allgemeine Protokollierung zu aktivieren, in der alle durchgeführten Abfragen aufgezeichnet werden:

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

    Dadurch werden laufende Abfragen an der folgenden Stelle in eine Textdatei geschrieben.

    C:\ProgramData\MySQL\MySQL Server 5.5\data\development.log
    
  3. Erstellen/Ausführen einer Konsolenanwendung, die die Protokollinformationen in Echtzeit ausgibt:

    Quelle steht hier zum Download zur Verfügung

    Quelle:

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

Zusätzlich zu den vorherigen Antworten, die beschreiben, wie die allgemeine Protokollierung aktiviert wird, musste ich eine zusätzliche Variable in meiner Vanilla MySql 5.6-Installation ändern, bevor SQL in das Protokoll geschrieben wurde:

SET GLOBAL log_output = 'FILE';

Die Standardeinstellung war 'NONE'.

1
David B

Gibbs MySQL Spyglass

AgilData hat kürzlich den Gibbs MySQL Scalability Advisor (ein kostenloses Self-Service-Tool) eingeführt, mit dem Benutzer einen Livestream von Abfragen erfassen können, die in Gibbs hochgeladen werden. Spyglass (Open Source) überwacht die Interaktionen zwischen Ihren MySQL Servern und Client-Anwendungen. Eine Neukonfiguration oder ein Neustart des MySQL-Datenbankservers ist nicht erforderlich (Client oder App).

GitHub: AgilData/gibbs-mysql-spyglass

Erfahren Sie mehr: Packet Capture MySQL mit Rust

Installationsbefehl:

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