procesos - ver consultas mysql en tiempo real

¿Cómo puedo ver las consultas en vivo de MySQL?

Question

¿Cómo puedo rastrear las consultas de MySQL en mi servidor Linux a medida que ocurren?

Por ejemplo, me gustaría configurar algún tipo de escucha, luego solicitar una página web y ver todas las consultas que ejecuta el motor, o simplemente ver todas las consultas que se ejecutan en un servidor de producción. ¿Cómo puedo hacer esto?

Answer 1

Gibbs MySQL Spyglass

AgilData lanzó recientemente el Asesor de escalabilidad MySQL de Gibbs (una herramienta gratuita de autoservicio) que permite a los usuarios capturar un flujo de consultas en vivo que se pueden cargar 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: Paquete de captura de MySQL con Rust

Instalar el comando:

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

Answer 2

strace

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

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

Ya que hay muchos caracteres escapados, puede formatear la salida de strace canalizando (solo agregue | entre estas dos líneas) en el siguiente comando:

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"

Por lo tanto, debería ver consultas SQL bastante limpias sin tiempo, sin tocar los archivos de configuración.

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

dtrace

Use las sondas MySQL para ver las consultas en vivo de MySQL sin tocar el servidor. Ejemplo 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));
}

Guarde la secuencia de comandos anterior en un archivo (como watch.d ) y ejecute:

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

Más información: Cómo comenzar a usar MySQL con DTracing

Gibbs MySQL Spyglass

Ver esta answer

Troncos

Aquí están los pasos útiles para las propuestas de desarrollo.

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

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

_{Las rutas: /var/log/mysqld.log o /usr/local/var/log/mysqld.log también pueden funcionar según sus 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 poder usarlo en el futuro), luego elimine el archivo y reinicie el servidor SQL nuevamente: killall -HUP mysqld .

Answer 3

A pesar de que ya se ha aceptado una respuesta, me gustaría presentar la 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 mysql que desea ejecutar el comando como
• -p Solicite su contraseña (para que no tenga que guardarla en un archivo o que el comando aparezca en su historial de comandos)
• i El intervalo en segundos.
• Utilice el indicador --verbose para mostrar la lista de procesos completa, mostrando la consulta completa para cada proceso. (Gracias, nmat )

Hay 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 lo verá.

Utilice esta opción preferiblemente cuando quiera verificar rápidamente las consultas en ejecución sin tener que configurar un escucha o cualquier otra cosa.

Answer 4

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 vainilla MySql 5.6 antes de escribir cualquier SQL en el registro:

SET GLOBAL log_output = ''FILE'';

El ajuste predeterminado era ''NINGUNO''.

Answer 5

Casi 10 años después de que hizo su pregunta, muchas cosas han cambiado en el mundo de monitoreo de DB. Existen varias buenas herramientas disponibles en la actualidad diseñadas con el único propósito de monitorear RDBMS. Personalmente uso y recomiendo Navicat Monitor .

Incluye un analizador de consultas que supervisa sus consultas en tiempo real y muestra información resumida de todas las consultas en ejecución. La información incluye las principales consultas con el recuento acumulativo de tiempo de ejecución, las consultas lentas y los puntos muertos. Aquí hay una captura de pantalla:

La versión más reciente, 1.7, incluye un modo de panel de control compacto. ¡Puede mostrar información resumida de literalmente cientos de instancias en una pantalla!

Answer 6

Desde una línea de comando puedes ejecutar:

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

Reemplaza los valores [x] con tus valores.

O mejor:

 mysqladmin -u root -p -i 1 processlist;

Answer 7

Echa un vistazo a mtop .

Answer 8

Ejecute esta consulta SQL conveniente para ver las consultas de MySQL en ejecución. Puede ejecutarse 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í solo se ejecuta sin ninguna configuración especial.

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

El único inconveniente es que a menudo se pierden las consultas que se ejecutan muy rápidamente, por lo que es más útil para consultas de ejecución más prolongada o cuando el servidor MySQL tiene consultas que están realizando copias de seguridad. En mi experiencia, este es exactamente el momento en el que quiero ver " consultas en vivo ".

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

Ej. Muestra todas las consultas ejecutándose durante 5 segundos o más:

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

Ej. Mostrar todas las ACTUALIZACIONES en ejecución:

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

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

Answer 9

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

Busque y abra su archivo de configuración de MySQL, generalmente /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 un nuevo terminal y ejecute este comando para desplazarse por el archivo de registro, ajustando la ruta si es necesario.

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

Ahora ejecuta tu aplicación. Verás que las consultas de la base de datos comienzan a volar en tu ventana de terminal. (Asegúrate de que tienes el desplazamiento y el historial habilitado en el terminal)

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

Answer 10

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 activador, pero sí tenía permisos para llamar a show processlist. Entonces, hice un mejor esfuerzo y se me ocurrió esto:

Cree un script de 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

Ejecutar el script:

./showsqlprocesslist > showsqlprocesslist.out &

Cola la salida:

tail -f showsqlprocesslist.out

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

Answer 11

He estado buscando hacer lo mismo y he creado una solución de varias publicaciones, además de haber creado una pequeña aplicación de consola para generar el texto de la consulta en vivo tal como está escrito 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 otras publicaciones, todo aquí para simplificar):

1. Edite el archivo ubicado en:

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

   Agregue "log = development.log" al final del archivo. (Tenga en cuenta que guardar este archivo requiere que ejecute mi editor de texto como administrador).

2. Use MySql workbench para abrir una línea de comando, ingrese 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. Cree / ejecute una aplicación de consola que genere 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);
   }
   }
   }
   }

Answer 12

Puede registrar cada consulta en un archivo de registro de forma muy sencilla:

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 db). Grep o de otro modo examine /var/run/mysqld/mysqld.log

Entonces no te olvides de

mysql> SET GLOBAL general_log = ''OFF'';

o el rendimiento caerá en picado y tu disco se llenará!

Answer 13

Puede ejecutar el comando MySQL SHOW FULL PROCESSLIST; para ver qué consultas se están procesando en un momento dado, pero eso probablemente no logrará lo que está esperando.

El mejor método para obtener un historial sin tener que modificar todas las aplicaciones que utilizan el servidor es probablemente a través de activadores. Puede configurar los desencadenantes para que cada ejecución de consulta resulte en la inserción de la consulta en algún tipo de tabla de historial y luego crear una página separada para acceder a esta información.

Tenga en cuenta que esto probablemente ralentizará considerablemente todo el servidor, sin embargo, con la adición de un INSERT adicional sobre cada consulta.

Edición: otra alternativa es el Registro de consultas generales , pero si se escribe en un archivo plano se eliminarán muchas posibilidades de flexibilidad de visualización, especialmente en tiempo real. Si solo quieres una forma simple y fácil de implementar para ver lo que está pasando, habilitar el GQL y luego usar la ejecución de tail -f en el archivo de registro será una gran ayuda.