Comment afficher les requêtes MySQL en direct?

Comment puis-je suivre les requêtes MySQL sur mon serveur Linux au fur et à mesure qu'elles se produisent?

Par exemple, j'aimerais configurer une sorte d'écouteur, puis demander une page Web et afficher toutes les requêtes exécutées par le moteur, ou tout simplement afficher toutes les requêtes en cours d'exécution sur un serveur de production. Comment puis-je faire ceci?

Vous pouvez exécuter la commande MySQL SHOW FULL PROCESSLIST;pour voir quelles requêtes sont traitées à un moment donné, mais cela n'atteindra probablement pas ce que vous espérez.

La meilleure méthode pour obtenir un historique sans avoir à modifier chaque application utilisant le serveur est probablement par le biais de déclencheurs. Vous pouvez configurer des déclencheurs de sorte que chaque exécution de requête entraîne l'insertion de la requête dans une sorte de table d'historique, puis créer une page distincte pour accéder à ces informations.

N'oubliez pas que cela ralentira probablement considérablement tout sur le serveur, avec l'ajout d'un supplément INSERTau-dessus de chaque requête.

Modifier: une autre alternative est le journal général des requêtes , mais le faire écrire dans un fichier plat supprimerait beaucoup de possibilités de flexibilité d'affichage, en particulier en temps réel. Si vous voulez juste un moyen simple et facile à implémenter pour voir ce qui se passe, activer le GQL puis utiliser l'exécution tail -fsur le fichier journal ferait l'affaire.

Vous pouvez enregistrer chaque requête dans un fichier journal très facilement:

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

Faites vos requêtes (sur n'importe quel db). Grep ou autrement examiner/var/run/mysqld/mysqld.log

N'oubliez pas de

mysql> SET GLOBAL general_log = 'OFF';

ou les performances chuteront et votre disque se remplira!

Même si une réponse a déjà été acceptée, je voudrais présenter ce qui pourrait même être l'option la plus simple:

$ mysqladmin -u bob -p -i 1 processlist

Cela imprimera les requêtes en cours sur votre écran chaque seconde.

• -u L'utilisateur mysql sous lequel vous souhaitez exécuter la commande
• -p Demander votre mot de passe (vous n'avez donc pas à l'enregistrer dans un fichier ou à faire apparaître la commande dans l'historique de vos commandes)
• i L'intervalle en secondes.
• Utilisez l' --verboseindicateur pour afficher la liste complète des processus, affichant l'intégralité de la requête pour chaque processus. (Merci, nmat )

Il y a un inconvénient possible: les requêtes rapides peuvent ne pas apparaître si elles s'exécutent entre l'intervalle que vous avez configuré. IE: Mon intervalle est défini sur une seconde et s'il y a une requête qui prend .02quelques secondes pour s'exécuter et est exécutée entre les intervalles, vous ne la verrez pas.

Utilisez cette option de préférence lorsque vous souhaitez vérifier rapidement les requêtes en cours d'exécution sans avoir à configurer d'écouteur ni rien d'autre.

Exécutez cette requête SQL pratique pour voir l'exécution des requêtes MySQL. Il peut être exécuté à partir de n'importe quel environnement que vous aimez, quand vous le souhaitez, sans aucun changement de code ou surcharge. Il peut nécessiter une configuration des autorisations MySQL, mais pour moi, il fonctionne simplement sans aucune configuration spéciale.

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

Le seul inconvénient est que vous manquez souvent des requêtes qui s'exécutent très rapidement, il est donc très utile pour les requêtes plus longues ou lorsque le serveur MySQL a des requêtes qui sont en cours de sauvegarde - selon mon expérience, c'est exactement le moment où je veux afficher " requêtes "en direct".

Vous pouvez également ajouter des conditions pour la rendre plus spécifique à n'importe quelle requête SQL.

Par exemple, affiche toutes les requêtes exécutées pendant 5 secondes ou plus:

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

Par exemple, afficher toutes les mises à jour en cours d'exécution:

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

Pour plus de détails, voir: http://dev.mysql.com/doc/refman/5.1/en/processlist-table.html

Je suis dans une situation particulière où je n'ai pas l'autorisation d'activer la connexion et je n'aurais pas l'autorisation de voir les journaux s'ils étaient activés. Je n'ai pas pu ajouter de déclencheur, mais j'avais l'autorisation d'appeler show processlist. Donc, j'ai fait de mon mieux et j'ai trouvé ceci:

Créez un script bash appelé "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

Exécutez le script:

./showsqlprocesslist > showsqlprocesslist.out &

Tail la sortie:

tail -f showsqlprocesslist.out

Bingo bango. Même s'il n'est pas limité, il n'a pris que 2 à 4% de CPU sur les boîtes sur lesquelles je l'ai exécuté. J'espère que cela peut aider quelqu'un.

strace

Le moyen le plus rapide de voir les requêtes MySQL / MariaDB en direct est d'utiliser le débogueur. Sous Linux, vous pouvez utiliser strace, par exemple:

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

Puisqu'il y a beaucoup de caractères d'échappement, vous pouvez formater la sortie de strace par piping (ajoutez simplement |entre ces deux lignes simples ) ci-dessus dans la commande suivante:

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"

Vous devriez donc voir des requêtes SQL assez propres sans délai, sans toucher aux fichiers de configuration.

Évidemment, cela ne remplacera pas la manière standard d'activer les journaux, qui est décrite ci-dessous (qui implique de recharger le serveur SQL).

dtrace

Utilisez des sondes MySQL pour afficher les requêtes MySQL en direct sans toucher au serveur. Exemple de script:

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

Enregistrez le script ci-dessus dans un fichier (comme watch.d) et exécutez:

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

En savoir plus: Premiers pas avec DTracing MySQL

Gibbs MySQL Spyglass

Voir cette réponse .

Journaux

Voici les étapes utiles au développement proposé.

Ajoutez ces lignes dans votre ~/.my.cnfou global my.cnf:

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

_{Chemins d'accès: /var/log/mysqld.logou /usr/local/var/log/mysqld.logpeuvent également fonctionner en fonction de vos autorisations de fichier.}

puis redémarrez votre MySQL / MariaDB par (préfixez sudosi nécessaire):

killall -HUP mysqld

Vérifiez ensuite vos journaux:

tail -f /tmp/mysqld.log

Après la fin, le changement general_logà 0(vous pouvez l' utiliser à l' avenir), puis retirez à nouveau le fichier et redémarrez le serveur SQL: killall -HUP mysqld.

C'est la configuration la plus simple sur une machine Linux Ubuntu que j'ai rencontrée. Fou de voir toutes les requêtes en direct.

Recherchez et ouvrez votre fichier de configuration MySQL, généralement /etc/mysql/my.cnf sur Ubuntu. Recherchez la section qui dit «Journalisation et réplication»

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

Décommentez simplement la variable «log» pour activer la journalisation. Redémarrez MySQL avec cette commande:

sudo /etc/init.d/mysql restart

Nous sommes maintenant prêts à commencer à surveiller les requêtes au fur et à mesure qu'elles arrivent. Ouvrez un nouveau terminal et exécutez cette commande pour faire défiler le fichier journal, en ajustant le chemin si nécessaire.

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

Exécutez maintenant votre application. Vous verrez les requêtes de base de données commencer à voler dans votre fenêtre de terminal. (assurez-vous que le défilement et l'historique sont activés sur le terminal)

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

À partir d'une ligne de commande, vous pouvez exécuter:

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

Remplacez les valeurs [x] par vos valeurs.

Ou encore mieux:

 mysqladmin -u root -p -i 1 processlist;

Découvrez mtop .

J'ai cherché à faire de même, et j'ai concocté une solution à partir de divers articles, et j'ai créé une petite application de console pour sortir le texte de la requête en direct pendant qu'il est écrit dans le fichier journal. C'était important dans mon cas car j'utilise Entity Framework avec MySQL et je dois pouvoir inspecter le SQL généré.

Étapes pour créer le fichier journal (duplication d'autres articles, tous ici pour plus de simplicité):

1. Modifiez le fichier situé dans:

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

   Ajoutez "log = development.log" au bas du fichier. (Notez que l'enregistrement de ce fichier m'a obligé à exécuter mon éditeur de texte en tant qu'administrateur).

2. Utilisez MySql workbench pour ouvrir une ligne de commande, entrez le mot de passe.

   Exécutez ce qui suit pour activer la journalisation générale qui enregistrera toutes les requêtes exécutées:

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

   Cela entraînera l'écriture des requêtes en cours d'exécution dans un fichier texte à l'emplacement suivant.

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

3. Créez / exécutez une application console qui produira les informations du journal en temps réel:

   Source disponible pour téléchargement ici

   La source:

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

En plus des réponses précédentes décrivant comment activer la journalisation générale, j'ai dû modifier une variable supplémentaire dans mon installation vanilla MySql 5.6 avant d'écrire du SQL dans le journal:

SET GLOBAL log_output = 'FILE';

Le paramètre par défaut était «AUCUN».

Gibbs MySQL Spyglass

AgilData a récemment lancé Gibbs MySQL Scalability Advisor (un outil libre-service gratuit) qui permet aux utilisateurs de capturer un flux en direct de requêtes à télécharger sur Gibbs. Spyglass (qui est Open Source) surveillera les interactions entre vos serveurs MySQL et les applications clientes. Aucune reconfiguration ou redémarrage du serveur de base de données MySQL n'est nécessaire (client ou application).

GitHub: AgilData / gibbs-mysql-spyglass

Apprendre encore plus: Packet Capture MySQL with Rust

Commande d'installation:

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