¿Cómo puedo ver consultas MySQL en vivo?

Puede registrar cada consulta en un archivo de registro muy fácilmente:

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

Haga sus consultas (en cualquier base de datos). Grep o examinar de otro modo /var/run/mysqld/mysqld.log

Entonces no te olvides de

mysql> SET GLOBAL general_log = 'OFF';

O el rendimiento se desplomará y su disco se llenará!

Aunque ya se ha aceptado una respuesta, me gustaría presentar lo que podría ser la opción más simple:

$ mysqladmin -u bob -p -i 1 processlist

Esto imprimirá las consultas actuales en su pantalla cada segundo.

• -u El usuario de mysql que desea ejecutar el comando como
• -p Solicitar su contraseña (para que no tenga que guardarla en un archivo o hacer que el comando aparezca en su historial de comandos)
• i El intervalo, en segundos.
• Utilice la bandera --verbose para mostrar la lista completa de procesos, mostrando la consulta completa para cada proceso. (Gracias, nmat )

Existe un posible inconveniente: las consultas rápidas pueden no aparecer si se ejecutan entre el intervalo que configuró. IE: Mi intervalo se establece en un segundo y si hay una consulta que tarda .02 segundos en ejecutarse y se ejecuta entre intervalos, no la verá.

Utilice esta opción preferiblemente cuando desee comprobar rápidamente la ejecución de consultas sin tener que configurar un oyente o cualquier otra cosa.

Ejecute esta consulta SQL conveniente para ver la ejecución de consultas MySQL. Se puede ejecutar desde cualquier entorno que desee, cuando lo desee, sin ningún cambio de código o gastos generales. Puede requerir alguna configuración de permisos MySQL, pero para mí simplemente se ejecuta sin ninguna configuración especial.

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

El único problema es que a menudo se pierden consultas que se ejecutan muy rápidamente, por lo que es más útil para consultas que se ejecutan durante más tiempo o cuando el servidor MySQL tiene consultas que están respaldando-en mi experiencia, esto es exactamente el momento en el que quiero ver consultas "en vivo".

También puede agregar condiciones para que sea más específica cualquier consulta SQL.

Por ejemplo, muestra todas las consultas ejecutándose durante 5 segundos o más:

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

Por ejemplo, Mostrar todas las actualizaciones en ejecución:

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

Para más detalles ver: http://dev.mysql.com/doc/refman/5.1/en/processlist-table.html

Estoy en una situación particular en la que no tengo permisos para activar el inicio de sesión, y no tendría permisos para ver los registros si estuvieran activados. No pude agregar un disparador, pero tenía permisos para llamar a show processlist. Por lo tanto, le di un mejor esfuerzo y se me ocurrió esto:

Crea un script bash llamado "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

Ejecuta el script:

./showsqlprocesslist > showsqlprocesslist.out &

Sigue la salida:

tail -f showsqlprocesslist.out

Bingo bango. A pesar de que no está estrangulado, sólo tomó 2-4% de CPU en las cajas en las que lo ejecuté. Espero que esto ayude a alguien.

Esta es la configuración más fácil en una máquina Linux Ubuntu que he encontrado. Loco para ver todas las consultas en vivo.

Busque y abra su archivo de configuración de MySQL, normalmente /etc/mysql/my.cnf en Ubuntu. Busque la sección que dice "Registro y replicación"

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

Simplemente descomente la variable "log" para activar el registro. Reinicie MySQL con este comando:

sudo /etc/init.d/mysql restart

Ahora estamos listos para comenzar a monitorear las consultas a medida que ingresan. Abra una nueva terminal y ejecute este comando para desplácese por el archivo de registro, ajustando la ruta si es necesario.

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

Ahora ejecute su aplicación. Verá que las consultas de la base de datos comienzan a volar en la ventana de su terminal. (asegúrese de que tiene el desplazamiento y el historial habilitados en el terminal)

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

Desde una línea de comandos se puede ejecutar:

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

Reemplace los valores [x] con sus valores.

O incluso mejor:

 mysqladmin -u root -p -i 1 processlist;

Echa un vistazo a mtop.

strace

La forma más rápida de ver consultas en vivo de MySQL/MariaDB es usar debugger. En Linux puedes usar strace, por ejemplo:

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

Dado que hay muchos caracteres escapados, puede formatear la salida de strace por piping (solo agregue | entre estos dos one-liners) arriba en el siguiente comando: {[24]]}

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"

Así que debería ver consultas SQL bastante limpias sin tiempo, sin tocar los archivos de configuración.

Obviamente esto no reemplace la forma estándar de habilitar los registros, que se describe a continuación (que implica recargar el servidor SQL).

dtrace

Utilice las sondas MySQL para ver las consultas MySQL en vivo sin tocar el servidor. Script de ejemplo:

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

Guarde el script anterior en un archivo (como watch.d), y ejecute:

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

Más información: Primeros pasos con DTracing MySQL

Rust

AgilData lanzó recientemente el Gibbs MySQL Scalability Advisor (a herramienta de autoservicio gratuita) que permite a los usuarios capturar una transmisión en vivo de consultas para cargarlas en Gibbs. Spyglass (que es de Código Abierto) observará las interacciones entre sus servidores MySQL y las aplicaciones cliente. No es necesario reconfigurar o reiniciar el servidor de base de datos MySQL (ya sea cliente o aplicación).

GitHub: AgilData / gibbs-mysql-spyglass

Más información: Captura de paquetes MySQL con Rust

Comando de instalación: curl -s https://raw.githubusercontent.com/AgilData/gibbs-mysql-spyglass/master/install.sh | bash

Logs

Aquí están los pasos útiles para el desarrollo que propone.

Agregue estas líneas a su ~/.my.cnf o global my.cnf:

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

_{Rutas: /var/log/mysqld.log o /usr/local/var/log/mysqld.log también pueden funcionar dependiendo de los permisos de archivo.}

Luego reinicie su MySQL / MariaDB por (prefijo con sudo si es necesario):

killall -HUP mysqld

Luego revisa tus registros:

tail -f /tmp/mysqld.log

Después de finalizar, cambie general_log a 0 (para que pueda usarlo en el futuro), luego elimine el archivo y reinicie SQL server de nuevo: killall -HUP mysqld.

He estado buscando hacer lo mismo, y he improvisado una solución de varias publicaciones, además de crear una pequeña aplicación de consola para generar el texto de consulta en vivo a medida que se escribe en el archivo de registro. Esto fue importante en mi caso ya que estoy usando Entity Framework con MySQL y necesito poder inspeccionar el SQL generado.

Pasos para crear el archivo de registro (alguna duplicación de otros mensajes, todos aquí para simplificar):

1. Edite el archivo ubicado en:

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

   Añadir "log = desarrollo.log " al final del archivo. (Nota guardar este archivo me requirió ejecutar mi editor de texto como administrador).

2. Utilice MySQL workbench para abrir una línea de comandos, introduzca la contraseña.

   Ejecute lo siguiente para activar el registro general que registrará todas las consultas ejecutadas:

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

   Esto hará que las consultas en ejecución se escriban en un archivo de texto en la siguiente ubicación.

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

3. Crear / Ejecutar una aplicación de consola que generará la información de registro en tiempo real:

   Fuente disponible para descargar aquí

   Fuente:

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

Además de las respuestas anteriores que describían cómo habilitar el registro general, tuve que modificar una variable adicional en mi instalación de vanilla MySQL 5.6 antes de que se escribiera cualquier SQL en el registro:

SET GLOBAL log_output = 'FILE';

La configuración predeterminada era 'NONE'.